Logo for jsDocs.io

one

  • Version 2.7.4
  • Published
  • 48.3 MB
  • 55 dependencies
  • BSD-3-Clause license

Install

npm i one
yarn add one
pnpm add one

Overview

One is a React framework for web, iOS, and Android apps.

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable AESEncryptionKey

const AESEncryptionKey: typeof AESEncryptionKey;

    variable AESSealedData

    const AESSealedData: typeof AESSealedData;

      variable One

      const One: OneAPI;

        variable route

        const route: { feed: { $id: typeof postIdRoute }; notifications: {}; profile: {} };

          variable router

          const router: OneRouter.Router;

            Functions

            function closeIntercept

            closeIntercept: () => boolean;

            • Close the current intercept and restore the previous URL. This should be called from modal close handlers instead of router.back().

            function createAPIRoute

            createAPIRoute: <Path extends string = string>(
                handler: APIRouteHandler<OneRouter.RouteType<Path>['Params']>
            ) => APIRouteHandler<OneRouter.RouteType<Path>['Params']>;

            • Type helper for API route handlers with typed params.

              Example 1

              // app/api/users/[id]+api.ts
              import { createAPIRoute } from 'one'
              

              export const GET = createAPIRoute<'/api/users/[id]'>((request, { params, worker }) => {
                // params.id is typed as string
                // on cloudflare workers, worker.executionCtx.waitUntil() keeps background work alive
                worker?.executionCtx?.waitUntil(trackEvent(params.id))
                return Response.json({ id: params.id })
              })

            function createMiddleware

            createMiddleware: (middleware: Middleware) => Middleware;

              function createRoute

              createRoute: <Path extends string = string>() => {
                  useParams: () => any;
                  useActiveParams: () => any;
                  createLoader: <T>(
                      fn: (props: LoaderProps<Params>) => T
                  ) => (props: LoaderProps<Params>) => T;
              };

                function getHinge

                getHinge: () => Promise<HingeState | null>;

                  function getLinking

                  getLinking: (config?: OneLinkingConfig) => OneLinkingConfig;

                    function getLoaderTimingHistory

                    getLoaderTimingHistory: () => LoaderTimingEntry[];

                      function getSizeClass

                      getSizeClass: () => Promise<SizeClass>;

                        function getURL

                        getURL: () => any;

                          function handleSkewError

                          handleSkewError: () => boolean;

                            function href

                            href: <A extends OneRouter.Href<{ __branded__: any }>>(a: A) => A;

                            • Type-level utility function to help pass valid Href typed strings. Does not actually validate at runtime, though we could add this later.

                            function isChunkLoadError

                            isChunkLoadError: (err: unknown) => boolean;

                              function isInterceptedNavigation

                              isInterceptedNavigation: () => boolean;

                              • Check if the current navigation state is from an interception

                              function isResponse

                              isResponse: (res: any) => res is Response;

                                function loadWithRetry

                                loadWithRetry: <T>(
                                    loader: () => Promise<T>,
                                    options?: {
                                        attempts?: number;
                                        delayMs?: number;
                                        delay?: (ms: number) => Promise<void>;
                                        onChunkErrorExhausted?: () => boolean;
                                    }
                                ) => Promise<T>;

                                  function onClientLoaderResolve

                                  onClientLoaderResolve: (resolver: ClientLoaderResolver) => void;

                                    function onHingeChange

                                    onHingeChange: (_callback: (hinge: HingeState | null) => void) => () => void;

                                      function redirect

                                      redirect: (
                                          path: '__branded__' extends keyof OneRouter.Href ? string : OneRouter.Href,
                                          status?: number
                                      ) => Response;

                                        function refetchLoader

                                        refetchLoader: (pathname: string) => Promise<void>;

                                        • Imperatively refetch loader data for a given path.

                                          Parameter pathname

                                          The route path to refetch (e.g., '/users/123')

                                          Returns

                                          Promise that resolves when refetch completes https://onestack.dev/docs/api/hooks/useLoaderState#refetchloader

                                          Example 1

                                          await refetchLoader('/users/123')

                                        function removeParams

                                        removeParams: <T extends unknown>(state: T, paramNames: string[]) => T;

                                        • removes specified params from all routes at every nesting level of a navigation state

                                        function useAudioPlayer

                                        useAudioPlayer: (
                                            source?: AudioSource,
                                            options?: AudioPlayerOptions
                                        ) => AudioPlayer;

                                          function useAudioPlayerStatus

                                          useAudioPlayerStatus: (player: AudioPlayer) => AudioStatus;

                                            function useBatteryLevel

                                            useBatteryLevel: () => number;

                                              function useBatteryState

                                              useBatteryState: () => BatteryState;

                                                function useBlocker

                                                useBlocker: (shouldBlock: BlockerFunction | boolean) => Blocker;

                                                • Block navigation when a condition is met.

                                                  This is useful for preventing users from accidentally leaving a page with unsaved changes. Works with both browser navigation (back/forward, URL changes) and programmatic navigation.

                                                  Parameter shouldBlock

                                                  Either a boolean or a function that returns whether to block. When using a function, you receive the current and next locations and can make dynamic decisions.

                                                  Example 1

                                                  function EditForm() {
                                                    const [isDirty, setIsDirty] = useState(false)
                                                    const blocker = useBlocker(isDirty)
                                                  

                                                    return (
                                                      <>
                                                        <form onChange={() => setIsDirty(true)}>
                                                          {// form fields}
                                                        </form>
                                                  

                                                        {blocker.state === 'blocked' && (
                                                          <Dialog>
                                                            <p>You have unsaved changes. Leave anyway?</p>
                                                            <button onClick={blocker.reset}>Stay</button>
                                                            <button onClick={blocker.proceed}>Leave</button>
                                                          </Dialog>
                                                        )}
                                                      </>
                                                    )
                                                  }

                                                  Example 2

                                                  // Function-based blocking with location info
                                                  const blocker = useBlocker(({ currentLocation, nextLocation }) => {
                                                    // Only block when leaving this specific section
                                                    return currentLocation.startsWith('/edit') && !nextLocation.startsWith('/edit')
                                                  })

                                                function useCalendars

                                                useCalendars: () => [Calendar, ...Calendar[]];

                                                  function useFocusEffect

                                                  useFocusEffect: (effect: EffectCallback, deps?: any[]) => void;

                                                  • Run side effects when a screen is focused. The effect runs when the screen gains focus and cleans up when it loses focus.

                                                    Parameter effect

                                                    Memoized callback containing the effect, optionally returns cleanup function

                                                    Parameter deps

                                                    Optional dependency array, effect re-runs when dependencies change (if focused). Defaults to [] so a React-Navigation-style one-arg call (useFocusEffect(useCallback(fn, []))) works without crashing. https://onestack.dev/docs/api/hooks/useFocusEffect

                                                    Example 1

                                                    useFocusEffect(
                                                      useCallback(() => {
                                                        const subscription = subscribeToUpdates()
                                                        return () => subscription.unsubscribe()
                                                      }, []),
                                                      []
                                                    )

                                                  function useFonts

                                                  useFonts: (fonts: FontMap) => UseFontsResult;

                                                    function useHeaderHeight

                                                    useHeaderHeight: () => number;

                                                    • the height of the navigator header drawn above this screen, status bar included, in points. 0 where the screen shows no header.

                                                    function useHinge

                                                    useHinge: () => HingeState | null;

                                                      function useKeepAwake

                                                      useKeepAwake: (tag?: string) => void;

                                                        function useLoader

                                                        useLoader: <
                                                            Loader extends Function,
                                                            Returned = Loader extends (p: any) => any ? ReturnType<Loader> : unknown
                                                        >(
                                                            loader: Loader
                                                        ) => Returned extends Promise<any> ? Awaited<Returned> : Returned;

                                                        • Load route data with SSR/SSG support. Returns the loader's data directly. For loading state and refetch capability, use useLoaderState instead.

                                                          Parameter loader

                                                          The loader function exported from the route file

                                                          Returns

                                                          The awaited return value of your loader function https://onestack.dev/docs/api/hooks/useLoader

                                                          Example 1

                                                          export async function loader({ params }) {
                                                            return { user: await fetchUser(params.id) }
                                                          }
                                                          

                                                          export default function UserPage() {
                                                            const { user } = useLoader(loader)
                                                            return <div>{user.name}</div>
                                                          }

                                                        function useLoaderState

                                                        useLoaderState: <
                                                            Loader extends Function = any,
                                                            Returned = Loader extends (p: any) => any ? ReturnType<Loader> : unknown
                                                        >(
                                                            loader?: Loader
                                                        ) => Loader extends undefined
                                                            ? { refetch: () => Promise<void>; state: 'idle' | 'loading' }
                                                            : {
                                                                  data: Returned extends Promise<any> ? Awaited<Returned> : Returned;
                                                                  refetch: () => Promise<void>;
                                                                  state: 'idle' | 'loading';
                                                              };

                                                        • Access loader data with full state control including refetch capability. Use this when you need loading state or refetch; use useLoader for just data.

                                                          Parameter loader

                                                          The loader function (optional - omit for just refetch/state)

                                                          Returns

                                                          Object with data, state ('idle' | 'loading'), and refetch function https://onestack.dev/docs/api/hooks/useLoaderState

                                                          Example 1

                                                          const { data, state, refetch } = useLoaderState(loader)
                                                          

                                                          return (
                                                            <div>
                                                              {state === 'loading' && <Spinner />}
                                                              <button onClick={refetch}>Refresh</button>
                                                              <pre>{JSON.stringify(data)}</pre>
                                                            </div>
                                                          )

                                                        function useLocales

                                                        useLocales: () => [Locale, ...Locale[]];

                                                          function useLowPowerMode

                                                          useLowPowerMode: () => boolean;

                                                            function useMatch

                                                            useMatch: (routeId: string) => RouteMatch | undefined;

                                                            • Find a specific match by route ID.

                                                              Example 1

                                                              const docsMatch = useMatch('./docs/_layout.tsx')
                                                              const navItems = (docsMatch?.loaderData as DocsLayoutData | undefined)?.navItems

                                                            function useMatches

                                                            useMatches: () => RouteMatch[];

                                                            • Returns an array of all matched routes from root to the current page. Each match contains the route's loader data, params, and route ID.

                                                              On the server (SSR), this returns the matches computed during the request. On the client, this returns cached matches from hydration or the last navigation.

                                                              Example 1

                                                              // In a layout component
                                                              function DocsLayout({ children }) {
                                                                const matches = useMatches()
                                                                const pageMatch = matches[matches.length - 1]
                                                                const headings = (pageMatch?.loaderData as { headings?: Heading[] } | undefined)?.headings
                                                              

                                                                return (
                                                                  <div>
                                                                    <TableOfContents headings={headings} />
                                                                    {children}
                                                                  </div>
                                                                )
                                                              }

                                                              Example 2

                                                              // Building breadcrumbs
                                                              function Breadcrumbs() {
                                                                const matches = useMatches()
                                                              

                                                                return (
                                                                  <nav>
                                                                    {matches.map((match) => (
                                                                      <a key={match.routeId} href={match.pathname}>
                                                                        {(match.loaderData as { title?: string } | undefined)?.title ?? match.routeId}
                                                                      </a>
                                                                    ))}
                                                                  </nav>
                                                                )
                                                              }

                                                            function useNativeState

                                                            useNativeState: <T>(initial: T) => NativeState<T>;

                                                              function useNavigation

                                                              useNavigation: <T = NavigationProp<ParamListBase>>(parent?: string) => T;

                                                              • Returns the React Navigation navigation object for the current route. Provides low-level access to navigation actions, events, and screen options.

                                                                Parameter parent

                                                                Optional path to parent navigator (absolute like /(tabs) or relative like ../)

                                                                Returns

                                                                The navigation object with methods like setOptions, addListener, getParent https://onestack.dev/docs/api/hooks/useNavigation

                                                                Example 1

                                                                const navigation = useNavigation()
                                                                navigation.setOptions({ title: 'My Screen' })

                                                              function useNetworkState

                                                              useNetworkState: () => NetworkState;

                                                                function usePageMatch

                                                                usePageMatch: () => RouteMatch | undefined;

                                                                • Get the current page's match (the last/deepest match).

                                                                  Example 1

                                                                  const pageMatch = usePageMatch()
                                                                  const { title, description } = (pageMatch?.loaderData as PageMeta | undefined) ?? {}

                                                                function usePowerState

                                                                usePowerState: () => BatteryPowerState;

                                                                  function usePreventScreenCapture

                                                                  usePreventScreenCapture: (key?: string) => void;

                                                                    function useReservedRegions

                                                                    useReservedRegions: (
                                                                        options?: ReservedRegionOptions
                                                                    ) => readonly ReservedRegion[];

                                                                    • The regions reserved inside the nearest ReservedRegions.Provider, in its coordinates: a division (a fold content should not straddle) or an occlusion (a camera or system control hiding content). Active regions only unless includeInactive is set.

                                                                    function useReservedRegionsReady

                                                                    useReservedRegionsReady: () => boolean;

                                                                    • Whether the nearest provider has taken its first reading, an empty one included. It stays true for the provider's lifetime.

                                                                    function useScrollGroup

                                                                    useScrollGroup: (groupPath?: string) => void;

                                                                    • Register a route as a scroll group. Routes within the same scroll group preserve their scroll position when navigating between them.

                                                                      Parameter groupPath

                                                                      Optional path to define the group. Defaults to current pathname. https://onestack.dev/docs/api/hooks/useScrollGroup

                                                                      Example 1

                                                                      // app/dashboard/_layout.tsx
                                                                      export default function DashboardLayout() {
                                                                        useScrollGroup() // All /dashboard/* routes share scroll
                                                                        return <Slot />
                                                                      }

                                                                    function useSitemap

                                                                    useSitemap: () => SitemapType | null;

                                                                      function useSizeClass

                                                                      useSizeClass: () => SizeClass;

                                                                        function useSpanning

                                                                        useSpanning: () => boolean;

                                                                        • whether an active division spans the provider.

                                                                        function useStack

                                                                        useStack: () => UseStackResult;

                                                                          function useTabs

                                                                          useTabs: () => UseTabsResult;

                                                                            function useValidationState

                                                                            useValidationState: () => any;

                                                                              function useWindowSegments

                                                                              useWindowSegments: () => readonly WindowSegment[];

                                                                              • parts of the provider separated by an active full-span division. Put the provider around the full window to read window segments. Until its native reading arrives, the result is empty. An unspanned window has one segment. Occlusions do not divide a window.

                                                                              function validateParams

                                                                              validateParams: <
                                                                                  T extends ParamValidator<Record<string, unknown>, Record<string, unknown>>
                                                                              >(
                                                                                  validator: T,
                                                                                  input: Record<string, unknown>
                                                                              ) => InferParamOutput<T>;

                                                                              • Validate route params using the provided validator

                                                                                Parameter validator

                                                                                The validator to use (Standard Schema, Zod-like, or function)

                                                                                Parameter input

                                                                                The raw route params to validate

                                                                                Returns

                                                                                The validated and transformed params

                                                                                Throws

                                                                                ParamValidationError if validation fails

                                                                              function watchFile

                                                                              watchFile: (path: string) => void;

                                                                              • Register a file dependency for loader HMR. No-op on client, registers file path for watching on server.

                                                                              function zodParamValidator

                                                                              zodParamValidator: <T extends ZodLikeSchema<unknown>>(schema: T) => T;

                                                                              • Create a route param validator from a Zod schema.

                                                                                Example 1

                                                                                import { z } from 'zod'
                                                                                import { zodParamValidator } from 'one'
                                                                                

                                                                                export const validateParams = zodParamValidator(z.object({
                                                                                  id: z.string().uuid('Invalid ID format'),
                                                                                  slug: z.string().min(1, 'Slug is required'),
                                                                                }))

                                                                              Classes

                                                                              class ParamValidationError

                                                                              class ParamValidationError extends Error {}

                                                                              • Error thrown when route param validation fails

                                                                              constructor

                                                                              constructor(
                                                                                  message: string,
                                                                                  params: Record<string, unknown>,
                                                                                  issues?: unknown[]
                                                                              );

                                                                                property issues

                                                                                readonly issues: unknown[];

                                                                                  property params

                                                                                  readonly params: Record<string, unknown>;

                                                                                    property routerCode

                                                                                    readonly routerCode: string;

                                                                                      class RouteValidationError

                                                                                      class RouteValidationError extends Error {}

                                                                                      • Error thrown when async route validation fails

                                                                                      constructor

                                                                                      constructor(message: string, details?: Record<string, unknown>);

                                                                                        property details

                                                                                        readonly details?: Record<string, unknown>;

                                                                                          property routerCode

                                                                                          readonly routerCode: string;

                                                                                            Interfaces

                                                                                            interface AudioPlayer

                                                                                            interface AudioPlayer {}

                                                                                              property addListener

                                                                                              addListener: (
                                                                                                  event: 'playbackStatusUpdate',
                                                                                                  listener: (status: AudioStatus) => void
                                                                                              ) => AudioPlayerSubscription;

                                                                                                property currentTime

                                                                                                readonly currentTime: number;

                                                                                                  property duration

                                                                                                  readonly duration: number;

                                                                                                    property getStatus

                                                                                                    getStatus: () => AudioStatus;

                                                                                                      property id

                                                                                                      readonly id: string;

                                                                                                        property isAudioSamplingSupported

                                                                                                        readonly isAudioSamplingSupported: boolean;

                                                                                                          property isBuffering

                                                                                                          readonly isBuffering: boolean;

                                                                                                            property isLoaded

                                                                                                            readonly isLoaded: boolean;

                                                                                                              property loop

                                                                                                              loop: boolean;

                                                                                                                property muted

                                                                                                                muted: boolean;

                                                                                                                  property pause

                                                                                                                  pause: () => void;

                                                                                                                    property paused

                                                                                                                    readonly paused: boolean;

                                                                                                                      property play

                                                                                                                      play: () => void;

                                                                                                                        property playbackRate

                                                                                                                        readonly playbackRate: number;

                                                                                                                          property playing

                                                                                                                          readonly playing: boolean;

                                                                                                                            property remove

                                                                                                                            remove: () => void;

                                                                                                                              property removeAllListeners

                                                                                                                              removeAllListeners: () => void;

                                                                                                                                property replace

                                                                                                                                replace: (source: AudioSource) => void;

                                                                                                                                  property seekTo

                                                                                                                                  seekTo: (
                                                                                                                                      seconds: number,
                                                                                                                                      toleranceMillisBefore?: number,
                                                                                                                                      toleranceMillisAfter?: number
                                                                                                                                  ) => Promise<void>;

                                                                                                                                    property setPlaybackRate

                                                                                                                                    setPlaybackRate: (
                                                                                                                                        rate: number,
                                                                                                                                        pitchCorrectionQuality?: PitchCorrectionQuality
                                                                                                                                    ) => void;

                                                                                                                                      property shouldCorrectPitch

                                                                                                                                      shouldCorrectPitch: boolean;

                                                                                                                                        property volume

                                                                                                                                        volume: number;

                                                                                                                                          interface BatteryLevelEvent

                                                                                                                                          interface BatteryLevelEvent {}

                                                                                                                                            property batteryLevel

                                                                                                                                            batteryLevel: number;

                                                                                                                                              interface BatteryPowerModeEvent

                                                                                                                                              interface BatteryPowerModeEvent {}

                                                                                                                                                property lowPowerMode

                                                                                                                                                lowPowerMode: boolean;

                                                                                                                                                  interface BatteryPowerState

                                                                                                                                                  interface BatteryPowerState {}

                                                                                                                                                    property batteryLevel

                                                                                                                                                    batteryLevel: number;

                                                                                                                                                      property batteryState

                                                                                                                                                      batteryState: BatteryState;

                                                                                                                                                        property lowPowerMode

                                                                                                                                                        lowPowerMode: boolean;

                                                                                                                                                          interface BatteryStateEvent

                                                                                                                                                          interface BatteryStateEvent {}

                                                                                                                                                            property batteryState

                                                                                                                                                            batteryState: BatteryState;

                                                                                                                                                              interface BatterySubscription

                                                                                                                                                              interface BatterySubscription {}

                                                                                                                                                                method remove

                                                                                                                                                                remove: () => void;

                                                                                                                                                                  interface ComposeModalBottomSheetRef

                                                                                                                                                                  interface ComposeModalBottomSheetRef {}

                                                                                                                                                                    property hide

                                                                                                                                                                    hide: () => Promise<void>;

                                                                                                                                                                      interface ComposeSnackbarHostRef

                                                                                                                                                                      interface ComposeSnackbarHostRef {}

                                                                                                                                                                        property showSnackbar

                                                                                                                                                                        showSnackbar: (
                                                                                                                                                                            options: ComposeSnackbarShowOptions
                                                                                                                                                                        ) => Promise<ComposeSnackbarResult>;

                                                                                                                                                                          interface ComposeSnackbarShowOptions

                                                                                                                                                                          interface ComposeSnackbarShowOptions {}

                                                                                                                                                                            property actionLabel

                                                                                                                                                                            actionLabel?: string;

                                                                                                                                                                              property duration

                                                                                                                                                                              duration?: ComposeSnackbarDuration;

                                                                                                                                                                                property message

                                                                                                                                                                                message: string;

                                                                                                                                                                                  property withDismissAction

                                                                                                                                                                                  withDismissAction?: boolean;

                                                                                                                                                                                    interface HingeState

                                                                                                                                                                                    interface HingeState {}

                                                                                                                                                                                      property angle

                                                                                                                                                                                      angle: number;

                                                                                                                                                                                      • Angle of the hinge in radians.

                                                                                                                                                                                      property status

                                                                                                                                                                                      status: HingeStatus;

                                                                                                                                                                                        interface ImageData

                                                                                                                                                                                        interface ImageData {}

                                                                                                                                                                                        • Image data returned by ?imagedata imports. Install sharp to enable this feature: npm install sharp

                                                                                                                                                                                          NOTE: env.d.ts declares the same shape for ?imagedata module imports. Keep both definitions in sync.

                                                                                                                                                                                        property blurDataURL

                                                                                                                                                                                        blurDataURL: string;

                                                                                                                                                                                        • Base64 blur placeholder (10px wide)

                                                                                                                                                                                        property height

                                                                                                                                                                                        height: number;

                                                                                                                                                                                        • Image height in pixels

                                                                                                                                                                                        property src

                                                                                                                                                                                        src: string;

                                                                                                                                                                                        • URL path to the image

                                                                                                                                                                                        property width

                                                                                                                                                                                        width: number;

                                                                                                                                                                                        • Image width in pixels

                                                                                                                                                                                        interface MiddlewareContext

                                                                                                                                                                                        interface MiddlewareContext {}

                                                                                                                                                                                          index signature

                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                            interface NetworkState

                                                                                                                                                                                            interface NetworkState {}

                                                                                                                                                                                              property isConnected

                                                                                                                                                                                              isConnected: boolean;

                                                                                                                                                                                                property isInternetReachable

                                                                                                                                                                                                isInternetReachable: boolean;

                                                                                                                                                                                                  property type

                                                                                                                                                                                                  type: NetworkStateType;

                                                                                                                                                                                                    interface PagerRef

                                                                                                                                                                                                    interface PagerRef {}

                                                                                                                                                                                                      method setPage

                                                                                                                                                                                                      setPage: (index: number) => void;

                                                                                                                                                                                                        method setPageWithoutAnimation

                                                                                                                                                                                                        setPageWithoutAnimation: (index: number) => void;

                                                                                                                                                                                                          method setScrollEnabled

                                                                                                                                                                                                          setScrollEnabled: (enabled: boolean) => void;

                                                                                                                                                                                                            interface ReservedRegion

                                                                                                                                                                                                            interface ReservedRegion {}

                                                                                                                                                                                                            • A region reserved inside a ReservedRegions.Provider, in its coordinates.

                                                                                                                                                                                                            property frame

                                                                                                                                                                                                            frame: {
                                                                                                                                                                                                                x: number;
                                                                                                                                                                                                                y: number;
                                                                                                                                                                                                                width: number;
                                                                                                                                                                                                                height: number;
                                                                                                                                                                                                            };

                                                                                                                                                                                                            • The reserved rect including margins, in the provider's coordinates.

                                                                                                                                                                                                            property id

                                                                                                                                                                                                            id: string;

                                                                                                                                                                                                              property isActive

                                                                                                                                                                                                              isActive: boolean;

                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                kind: ReservedRegionKind;

                                                                                                                                                                                                                  property margins

                                                                                                                                                                                                                  margins: {
                                                                                                                                                                                                                      top: number;
                                                                                                                                                                                                                      left: number;
                                                                                                                                                                                                                      bottom: number;
                                                                                                                                                                                                                      right: number;
                                                                                                                                                                                                                  };

                                                                                                                                                                                                                  • Room kept around the reserved rect for interactive content.

                                                                                                                                                                                                                  interface ReservedRegionOptions

                                                                                                                                                                                                                  interface ReservedRegionOptions {}

                                                                                                                                                                                                                    property includeInactive

                                                                                                                                                                                                                    includeInactive?: boolean;

                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                      kind?: ReservedRegionKind;

                                                                                                                                                                                                                        interface ScrollViewProxy

                                                                                                                                                                                                                        interface ScrollViewProxy {}

                                                                                                                                                                                                                          method scrollTo

                                                                                                                                                                                                                          scrollTo: (id: string, anchor?: UnitPoint | null) => void;

                                                                                                                                                                                                                            interface ScrollViewReaderProps

                                                                                                                                                                                                                            interface ScrollViewReaderProps extends Omit<ViewProps, 'children'> {}

                                                                                                                                                                                                                              property children

                                                                                                                                                                                                                              children: (proxy: ScrollViewProxy) => ReactNode;

                                                                                                                                                                                                                                interface SizeClass

                                                                                                                                                                                                                                interface SizeClass {}

                                                                                                                                                                                                                                  property horizontal

                                                                                                                                                                                                                                  horizontal: UserInterfaceSizeClass;

                                                                                                                                                                                                                                    property vertical

                                                                                                                                                                                                                                    vertical: UserInterfaceSizeClass;

                                                                                                                                                                                                                                      interface WindowSegment

                                                                                                                                                                                                                                      interface WindowSegment {}

                                                                                                                                                                                                                                      • an unobstructed part of a ReservedRegions.Provider, in its coordinates. This is a window segment when the provider fills the window.

                                                                                                                                                                                                                                      property height

                                                                                                                                                                                                                                      height: number;

                                                                                                                                                                                                                                        property width

                                                                                                                                                                                                                                        width: number;

                                                                                                                                                                                                                                          property x

                                                                                                                                                                                                                                          x: number;

                                                                                                                                                                                                                                            property y

                                                                                                                                                                                                                                            y: number;

                                                                                                                                                                                                                                              Type Aliases

                                                                                                                                                                                                                                              type APIRouteContext

                                                                                                                                                                                                                                              type APIRouteContext<
                                                                                                                                                                                                                                                  Params extends Record<string, string> = Record<string, string>
                                                                                                                                                                                                                                              > = {
                                                                                                                                                                                                                                                  params: Params;
                                                                                                                                                                                                                                                  /** Present on worker runtimes (Cloudflare Workers). Undefined in dev/Node. */
                                                                                                                                                                                                                                                  worker?: WorkerContext;
                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                type APIRouteHandler

                                                                                                                                                                                                                                                type APIRouteHandler<
                                                                                                                                                                                                                                                    Params extends Record<string, string> = Record<string, string>
                                                                                                                                                                                                                                                > = (request: Request, context: APIRouteContext<Params>) => MaybePromise<Response>;

                                                                                                                                                                                                                                                  type AudioPlayerOptions

                                                                                                                                                                                                                                                  type AudioPlayerOptions = {
                                                                                                                                                                                                                                                      updateInterval?: number;
                                                                                                                                                                                                                                                      crossOrigin?: 'anonymous' | 'use-credentials';
                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                    type AudioPlayerSubscription

                                                                                                                                                                                                                                                    type AudioPlayerSubscription = {
                                                                                                                                                                                                                                                        remove: () => void;
                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                      type AudioSource

                                                                                                                                                                                                                                                      type AudioSource = string | number | AudioSourceObject | null;

                                                                                                                                                                                                                                                        type AudioSourceObject

                                                                                                                                                                                                                                                        type AudioSourceObject = {
                                                                                                                                                                                                                                                            uri?: string;
                                                                                                                                                                                                                                                            headers?: Record<string, string>;
                                                                                                                                                                                                                                                            name?: string;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          type AudioStatus

                                                                                                                                                                                                                                                          type AudioStatus = {
                                                                                                                                                                                                                                                              currentTime: number;
                                                                                                                                                                                                                                                              didJustFinish: boolean;
                                                                                                                                                                                                                                                              duration: number;
                                                                                                                                                                                                                                                              error: string | null;
                                                                                                                                                                                                                                                              id: string;
                                                                                                                                                                                                                                                              isBuffering: boolean;
                                                                                                                                                                                                                                                              isLoaded: boolean;
                                                                                                                                                                                                                                                              loop: boolean;
                                                                                                                                                                                                                                                              mute: boolean;
                                                                                                                                                                                                                                                              playbackRate: number;
                                                                                                                                                                                                                                                              playing: boolean;
                                                                                                                                                                                                                                                              shouldCorrectPitch?: boolean;
                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                            type BatteryState

                                                                                                                                                                                                                                                            type BatteryState = 'unknown' | 'unplugged' | 'charging' | 'full' | 'notCharging';

                                                                                                                                                                                                                                                              type Blocker

                                                                                                                                                                                                                                                              type Blocker =
                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                        state: 'unblocked';
                                                                                                                                                                                                                                                                        reset?: undefined;
                                                                                                                                                                                                                                                                        proceed?: undefined;
                                                                                                                                                                                                                                                                        location?: undefined;
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                        state: 'blocked';
                                                                                                                                                                                                                                                                        reset: () => void;
                                                                                                                                                                                                                                                                        proceed: () => void;
                                                                                                                                                                                                                                                                        location: string;
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                        state: 'proceeding';
                                                                                                                                                                                                                                                                        reset?: undefined;
                                                                                                                                                                                                                                                                        proceed?: undefined;
                                                                                                                                                                                                                                                                        location: string;
                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                type BlockerFunction

                                                                                                                                                                                                                                                                type BlockerFunction = (args: {
                                                                                                                                                                                                                                                                    currentLocation: string;
                                                                                                                                                                                                                                                                    nextLocation: string;
                                                                                                                                                                                                                                                                    historyAction: 'push' | 'pop' | 'replace';
                                                                                                                                                                                                                                                                }) => boolean;

                                                                                                                                                                                                                                                                  type BlockerState

                                                                                                                                                                                                                                                                  type BlockerState = 'unblocked' | 'blocked' | 'proceeding';

                                                                                                                                                                                                                                                                    type ComposeSnackbarResult

                                                                                                                                                                                                                                                                    type ComposeSnackbarResult = 'dismissed' | 'actionPerformed';

                                                                                                                                                                                                                                                                      type Endpoint

                                                                                                                                                                                                                                                                      type Endpoint = (req: Request) => Response | string | object | null;

                                                                                                                                                                                                                                                                        type FontMap

                                                                                                                                                                                                                                                                        type FontMap = Readonly<Record<string, FontSource>>;

                                                                                                                                                                                                                                                                          type FontSource

                                                                                                                                                                                                                                                                          type FontSource = number | string;

                                                                                                                                                                                                                                                                            type HingeStatus

                                                                                                                                                                                                                                                                            type HingeStatus = 'unknown' | 'closed' | 'partiallyOpen' | 'fullyOpen';

                                                                                                                                                                                                                                                                              type Href

                                                                                                                                                                                                                                                                              type Href = '__branded__' extends keyof OneRouter.Href ? string : OneRouter.Href;

                                                                                                                                                                                                                                                                                type InferParamInput

                                                                                                                                                                                                                                                                                type InferParamInput<T> = T extends StandardSchema<infer I, any>
                                                                                                                                                                                                                                                                                    ? I
                                                                                                                                                                                                                                                                                    : T extends ZodLikeSchema<any>
                                                                                                                                                                                                                                                                                    ? Record<string, unknown>
                                                                                                                                                                                                                                                                                    : T extends SearchValidatorFn<infer I, any>
                                                                                                                                                                                                                                                                                    ? I
                                                                                                                                                                                                                                                                                    : never;

                                                                                                                                                                                                                                                                                • Infer the input type from a param validator

                                                                                                                                                                                                                                                                                type InferParamOutput

                                                                                                                                                                                                                                                                                type InferParamOutput<T> = T extends StandardSchema<any, infer O>
                                                                                                                                                                                                                                                                                    ? O
                                                                                                                                                                                                                                                                                    : T extends ZodLikeSchema<infer O>
                                                                                                                                                                                                                                                                                    ? O
                                                                                                                                                                                                                                                                                    : T extends SearchValidatorFn<any, infer O>
                                                                                                                                                                                                                                                                                    ? O
                                                                                                                                                                                                                                                                                    : never;

                                                                                                                                                                                                                                                                                • Infer the output type from a param validator

                                                                                                                                                                                                                                                                                type LinkProps

                                                                                                                                                                                                                                                                                type LinkProps<T extends string | object = string> = OneRouter.LinkProps<T>;

                                                                                                                                                                                                                                                                                  type LoaderProps

                                                                                                                                                                                                                                                                                  type LoaderProps<Params extends object = Record<string, string | string[]>> = {
                                                                                                                                                                                                                                                                                      path: string;
                                                                                                                                                                                                                                                                                      search?: string;
                                                                                                                                                                                                                                                                                      subdomain?: string;
                                                                                                                                                                                                                                                                                      params: Params;
                                                                                                                                                                                                                                                                                      request?: Request;
                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                    type LoaderTimingEntry

                                                                                                                                                                                                                                                                                    type LoaderTimingEntry = {
                                                                                                                                                                                                                                                                                        path: string;
                                                                                                                                                                                                                                                                                        startTime: number;
                                                                                                                                                                                                                                                                                        moduleLoadTime?: number;
                                                                                                                                                                                                                                                                                        executionTime?: number;
                                                                                                                                                                                                                                                                                        totalTime?: number;
                                                                                                                                                                                                                                                                                        error?: string;
                                                                                                                                                                                                                                                                                        source: 'preload' | 'initial' | 'refetch';
                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                      type Middleware

                                                                                                                                                                                                                                                                                      type Middleware = (props: {
                                                                                                                                                                                                                                                                                          request: Request;
                                                                                                                                                                                                                                                                                          next: () => Promise<MaybeResponse>;
                                                                                                                                                                                                                                                                                          context: MiddlewareContext;
                                                                                                                                                                                                                                                                                      }) => RequestResponse;

                                                                                                                                                                                                                                                                                        type ModalPresentationOptions

                                                                                                                                                                                                                                                                                        type ModalPresentationOptions = {
                                                                                                                                                                                                                                                                                            gestureEnabled?: boolean;
                                                                                                                                                                                                                                                                                            title?: string;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          type ModalPresentationProps

                                                                                                                                                                                                                                                                                          type ModalPresentationProps = PresentationProps<ModalPresentationOptions>;

                                                                                                                                                                                                                                                                                            type NativeState

                                                                                                                                                                                                                                                                                            type NativeState<T> = SyncState<T>;

                                                                                                                                                                                                                                                                                              type NetworkStateType

                                                                                                                                                                                                                                                                                              type NetworkStateType =
                                                                                                                                                                                                                                                                                                  | 'none'
                                                                                                                                                                                                                                                                                                  | 'unknown'
                                                                                                                                                                                                                                                                                                  | 'cellular'
                                                                                                                                                                                                                                                                                                  | 'wifi'
                                                                                                                                                                                                                                                                                                  | 'bluetooth'
                                                                                                                                                                                                                                                                                                  | 'ethernet'
                                                                                                                                                                                                                                                                                                  | 'wimax'
                                                                                                                                                                                                                                                                                                  | 'vpn'
                                                                                                                                                                                                                                                                                                  | 'other';

                                                                                                                                                                                                                                                                                                type OneLinkingConfig

                                                                                                                                                                                                                                                                                                type OneLinkingConfig = {
                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                     * Custom app scheme or schemes. Each scheme is expanded to double- and
                                                                                                                                                                                                                                                                                                     * triple-slashed URL prefixes.
                                                                                                                                                                                                                                                                                                     */
                                                                                                                                                                                                                                                                                                    scheme?: string | string[];
                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                     * Fully qualified URL prefixes to strip before matching routes.
                                                                                                                                                                                                                                                                                                     *
                                                                                                                                                                                                                                                                                                     * For host-bearing custom scheme URLs, include the host:
                                                                                                                                                                                                                                                                                                     * `myapp://app`.
                                                                                                                                                                                                                                                                                                     */
                                                                                                                                                                                                                                                                                                    prefixes?: string[];
                                                                                                                                                                                                                                                                                                    filter?: (url: string) => boolean;
                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                  type PagerProps

                                                                                                                                                                                                                                                                                                  type PagerProps = ViewProps & {
                                                                                                                                                                                                                                                                                                      children?: ReactNode;
                                                                                                                                                                                                                                                                                                      initialPage?: number;
                                                                                                                                                                                                                                                                                                      scrollEnabled?: boolean;
                                                                                                                                                                                                                                                                                                      orientation?: 'horizontal' | 'vertical';
                                                                                                                                                                                                                                                                                                      layoutDirection?: 'ltr' | 'rtl';
                                                                                                                                                                                                                                                                                                      offscreenPageLimit?: number;
                                                                                                                                                                                                                                                                                                      pageMargin?: number;
                                                                                                                                                                                                                                                                                                      overdrag?: boolean;
                                                                                                                                                                                                                                                                                                      overScrollMode?: 'auto' | 'always' | 'never';
                                                                                                                                                                                                                                                                                                      keyboardDismissMode?: 'none' | 'on-drag';
                                                                                                                                                                                                                                                                                                      onPageScroll?: (event: PagerScrollEvent) => void;
                                                                                                                                                                                                                                                                                                      onPageSelected?: (event: PagerSelectedEvent) => void;
                                                                                                                                                                                                                                                                                                      onPageScrollStateChanged?: (event: PagerScrollStateEvent) => void;
                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                    type PagerScrollEvent

                                                                                                                                                                                                                                                                                                    type PagerScrollEvent = Readonly<{
                                                                                                                                                                                                                                                                                                        nativeEvent: Readonly<{ position: number; offset: number }>;
                                                                                                                                                                                                                                                                                                    }>;

                                                                                                                                                                                                                                                                                                      type PagerScrollStateEvent

                                                                                                                                                                                                                                                                                                      type PagerScrollStateEvent = Readonly<{
                                                                                                                                                                                                                                                                                                          nativeEvent: Readonly<{
                                                                                                                                                                                                                                                                                                              pageScrollState: 'idle' | 'dragging' | 'settling';
                                                                                                                                                                                                                                                                                                          }>;
                                                                                                                                                                                                                                                                                                      }>;

                                                                                                                                                                                                                                                                                                        type PagerSelectedEvent

                                                                                                                                                                                                                                                                                                        type PagerSelectedEvent = Readonly<{ nativeEvent: Readonly<{ position: number }> }>;

                                                                                                                                                                                                                                                                                                          type ParamValidator

                                                                                                                                                                                                                                                                                                          type ParamValidator<TInput = Record<string, unknown>, TOutput = TInput> =
                                                                                                                                                                                                                                                                                                              | StandardSchema<TInput, TOutput>
                                                                                                                                                                                                                                                                                                              | ZodLikeSchema<TOutput>
                                                                                                                                                                                                                                                                                                              | SearchValidatorFn<TInput, TOutput>;

                                                                                                                                                                                                                                                                                                          • All supported validator types for route params

                                                                                                                                                                                                                                                                                                          type PitchCorrectionQuality

                                                                                                                                                                                                                                                                                                          type PitchCorrectionQuality = 'low' | 'medium' | 'high';

                                                                                                                                                                                                                                                                                                            type PortalHostProps

                                                                                                                                                                                                                                                                                                            type PortalHostProps = ViewProps & { name: string; children?: ReactNode };

                                                                                                                                                                                                                                                                                                              type PortalProps

                                                                                                                                                                                                                                                                                                              type PortalProps = ViewProps & {
                                                                                                                                                                                                                                                                                                                  hostName?: string;
                                                                                                                                                                                                                                                                                                                  name?: string;
                                                                                                                                                                                                                                                                                                                  children: ReactNode;
                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                type ReservedRegionKind

                                                                                                                                                                                                                                                                                                                type ReservedRegionKind = 'division' | 'occlusion';

                                                                                                                                                                                                                                                                                                                  type RouteMatch

                                                                                                                                                                                                                                                                                                                  type RouteMatch = One.RouteMatch;

                                                                                                                                                                                                                                                                                                                  • Re-export for convenience

                                                                                                                                                                                                                                                                                                                  type RouteType

                                                                                                                                                                                                                                                                                                                  type RouteType<Path extends string = string> = OneRouter.RouteType<Path>;

                                                                                                                                                                                                                                                                                                                  • Helper type to get route information including params and loader props. Can be overridden in generated routes.d.ts for per-route types.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    import type { RouteType } from 'one'

                                                                                                                                                                                                                                                                                                                    type MyRoute = RouteType<'(site)/docs/[slug]'> // MyRoute.Params = { slug: string } // MyRoute.LoaderProps = { params: { slug: string }, path: string, request?: Request }

                                                                                                                                                                                                                                                                                                                  type RouteValidationFn

                                                                                                                                                                                                                                                                                                                  type RouteValidationFn = (
                                                                                                                                                                                                                                                                                                                      props: ValidateRouteProps
                                                                                                                                                                                                                                                                                                                  ) => ValidationResult | Promise<ValidationResult> | void | Promise<void>;

                                                                                                                                                                                                                                                                                                                  • Async route validation function type

                                                                                                                                                                                                                                                                                                                  type ScreenEntry

                                                                                                                                                                                                                                                                                                                  type ScreenEntry = {
                                                                                                                                                                                                                                                                                                                      key: string;
                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                      params: Record<string, any>;
                                                                                                                                                                                                                                                                                                                      href: string;
                                                                                                                                                                                                                                                                                                                      isFocused: boolean;
                                                                                                                                                                                                                                                                                                                      keepMounted: boolean;
                                                                                                                                                                                                                                                                                                                      // compiled options: semantic keys plus opaque passthrough of preset keys
                                                                                                                                                                                                                                                                                                                      options: Record<string, any>;
                                                                                                                                                                                                                                                                                                                      // lazy: rendering it mounts the route (descriptor.render underneath)
                                                                                                                                                                                                                                                                                                                      element: ReactElement;
                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                    type SFSymbolName

                                                                                                                                                                                                                                                                                                                    type SFSymbolName =
                                                                                                                                                                                                                                                                                                                        | '0.circle'
                                                                                                                                                                                                                                                                                                                        | '0.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '0.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '0.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '0.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '0.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '0.square'
                                                                                                                                                                                                                                                                                                                        | '0.square.ar'
                                                                                                                                                                                                                                                                                                                        | '0.square.fill'
                                                                                                                                                                                                                                                                                                                        | '0.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '0.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '0.square.hi'
                                                                                                                                                                                                                                                                                                                        | '00.circle'
                                                                                                                                                                                                                                                                                                                        | '00.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '00.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '00.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '00.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '00.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '00.square'
                                                                                                                                                                                                                                                                                                                        | '00.square.ar'
                                                                                                                                                                                                                                                                                                                        | '00.square.fill'
                                                                                                                                                                                                                                                                                                                        | '00.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '00.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '00.square.hi'
                                                                                                                                                                                                                                                                                                                        | '01.circle'
                                                                                                                                                                                                                                                                                                                        | '01.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '01.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '01.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '01.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '01.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '01.square'
                                                                                                                                                                                                                                                                                                                        | '01.square.ar'
                                                                                                                                                                                                                                                                                                                        | '01.square.fill'
                                                                                                                                                                                                                                                                                                                        | '01.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '01.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '01.square.hi'
                                                                                                                                                                                                                                                                                                                        | '02.circle'
                                                                                                                                                                                                                                                                                                                        | '02.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '02.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '02.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '02.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '02.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '02.square'
                                                                                                                                                                                                                                                                                                                        | '02.square.ar'
                                                                                                                                                                                                                                                                                                                        | '02.square.fill'
                                                                                                                                                                                                                                                                                                                        | '02.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '02.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '02.square.hi'
                                                                                                                                                                                                                                                                                                                        | '03.circle'
                                                                                                                                                                                                                                                                                                                        | '03.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '03.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '03.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '03.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '03.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '03.square'
                                                                                                                                                                                                                                                                                                                        | '03.square.ar'
                                                                                                                                                                                                                                                                                                                        | '03.square.fill'
                                                                                                                                                                                                                                                                                                                        | '03.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '03.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '03.square.hi'
                                                                                                                                                                                                                                                                                                                        | '04.circle'
                                                                                                                                                                                                                                                                                                                        | '04.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '04.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '04.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '04.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '04.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '04.square'
                                                                                                                                                                                                                                                                                                                        | '04.square.ar'
                                                                                                                                                                                                                                                                                                                        | '04.square.fill'
                                                                                                                                                                                                                                                                                                                        | '04.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '04.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '04.square.hi'
                                                                                                                                                                                                                                                                                                                        | '05.circle'
                                                                                                                                                                                                                                                                                                                        | '05.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '05.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '05.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '05.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '05.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '05.square'
                                                                                                                                                                                                                                                                                                                        | '05.square.ar'
                                                                                                                                                                                                                                                                                                                        | '05.square.fill'
                                                                                                                                                                                                                                                                                                                        | '05.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '05.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '05.square.hi'
                                                                                                                                                                                                                                                                                                                        | '06.circle'
                                                                                                                                                                                                                                                                                                                        | '06.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '06.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '06.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '06.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '06.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '06.square'
                                                                                                                                                                                                                                                                                                                        | '06.square.ar'
                                                                                                                                                                                                                                                                                                                        | '06.square.fill'
                                                                                                                                                                                                                                                                                                                        | '06.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '06.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '06.square.hi'
                                                                                                                                                                                                                                                                                                                        | '07.circle'
                                                                                                                                                                                                                                                                                                                        | '07.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '07.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '07.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '07.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '07.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '07.square'
                                                                                                                                                                                                                                                                                                                        | '07.square.ar'
                                                                                                                                                                                                                                                                                                                        | '07.square.fill'
                                                                                                                                                                                                                                                                                                                        | '07.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '07.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '07.square.hi'
                                                                                                                                                                                                                                                                                                                        | '08.circle'
                                                                                                                                                                                                                                                                                                                        | '08.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '08.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '08.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '08.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '08.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '08.square'
                                                                                                                                                                                                                                                                                                                        | '08.square.ar'
                                                                                                                                                                                                                                                                                                                        | '08.square.fill'
                                                                                                                                                                                                                                                                                                                        | '08.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '08.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '08.square.hi'
                                                                                                                                                                                                                                                                                                                        | '09.circle'
                                                                                                                                                                                                                                                                                                                        | '09.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '09.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '09.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '09.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '09.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '09.square'
                                                                                                                                                                                                                                                                                                                        | '09.square.ar'
                                                                                                                                                                                                                                                                                                                        | '09.square.fill'
                                                                                                                                                                                                                                                                                                                        | '09.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '09.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '09.square.hi'
                                                                                                                                                                                                                                                                                                                        | '1.brakesignal'
                                                                                                                                                                                                                                                                                                                        | '1.calendar'
                                                                                                                                                                                                                                                                                                                        | '1.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '1.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '1.circle'
                                                                                                                                                                                                                                                                                                                        | '1.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '1.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '1.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '1.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '1.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '1.lane'
                                                                                                                                                                                                                                                                                                                        | '1.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '1.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '1.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | '1.magnifyingglass.ar'
                                                                                                                                                                                                                                                                                                                        | '1.magnifyingglass.hi'
                                                                                                                                                                                                                                                                                                                        | '1.square'
                                                                                                                                                                                                                                                                                                                        | '1.square.ar'
                                                                                                                                                                                                                                                                                                                        | '1.square.fill'
                                                                                                                                                                                                                                                                                                                        | '1.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '1.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '1.square.hi'
                                                                                                                                                                                                                                                                                                                        | '10.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | '10.arrow.trianglehead.clockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '10.arrow.trianglehead.clockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '10.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | '10.arrow.trianglehead.counterclockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '10.arrow.trianglehead.counterclockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '10.calendar'
                                                                                                                                                                                                                                                                                                                        | '10.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '10.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '10.circle'
                                                                                                                                                                                                                                                                                                                        | '10.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '10.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '10.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '10.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '10.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '10.lane'
                                                                                                                                                                                                                                                                                                                        | '10.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '10.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '10.square'
                                                                                                                                                                                                                                                                                                                        | '10.square.ar'
                                                                                                                                                                                                                                                                                                                        | '10.square.fill'
                                                                                                                                                                                                                                                                                                                        | '10.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '10.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '10.square.hi'
                                                                                                                                                                                                                                                                                                                        | '11.calendar'
                                                                                                                                                                                                                                                                                                                        | '11.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '11.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '11.circle'
                                                                                                                                                                                                                                                                                                                        | '11.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '11.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '11.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '11.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '11.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '11.lane'
                                                                                                                                                                                                                                                                                                                        | '11.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '11.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '11.square'
                                                                                                                                                                                                                                                                                                                        | '11.square.ar'
                                                                                                                                                                                                                                                                                                                        | '11.square.fill'
                                                                                                                                                                                                                                                                                                                        | '11.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '11.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '11.square.hi'
                                                                                                                                                                                                                                                                                                                        | '12.calendar'
                                                                                                                                                                                                                                                                                                                        | '12.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '12.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '12.circle'
                                                                                                                                                                                                                                                                                                                        | '12.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '12.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '12.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '12.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '12.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '12.lane'
                                                                                                                                                                                                                                                                                                                        | '12.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '12.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '12.square'
                                                                                                                                                                                                                                                                                                                        | '12.square.ar'
                                                                                                                                                                                                                                                                                                                        | '12.square.fill'
                                                                                                                                                                                                                                                                                                                        | '12.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '12.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '12.square.hi'
                                                                                                                                                                                                                                                                                                                        | '123.rectangle'
                                                                                                                                                                                                                                                                                                                        | '123.rectangle.ar'
                                                                                                                                                                                                                                                                                                                        | '123.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | '123.rectangle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '123.rectangle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '123.rectangle.hi'
                                                                                                                                                                                                                                                                                                                        | '13.calendar'
                                                                                                                                                                                                                                                                                                                        | '13.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '13.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '13.circle'
                                                                                                                                                                                                                                                                                                                        | '13.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '13.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '13.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '13.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '13.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '13.square'
                                                                                                                                                                                                                                                                                                                        | '13.square.ar'
                                                                                                                                                                                                                                                                                                                        | '13.square.fill'
                                                                                                                                                                                                                                                                                                                        | '13.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '13.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '13.square.hi'
                                                                                                                                                                                                                                                                                                                        | '14.calendar'
                                                                                                                                                                                                                                                                                                                        | '14.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '14.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '14.circle'
                                                                                                                                                                                                                                                                                                                        | '14.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '14.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '14.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '14.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '14.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '14.square'
                                                                                                                                                                                                                                                                                                                        | '14.square.ar'
                                                                                                                                                                                                                                                                                                                        | '14.square.fill'
                                                                                                                                                                                                                                                                                                                        | '14.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '14.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '14.square.hi'
                                                                                                                                                                                                                                                                                                                        | '15.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | '15.arrow.trianglehead.clockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '15.arrow.trianglehead.clockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '15.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | '15.arrow.trianglehead.counterclockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '15.arrow.trianglehead.counterclockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '15.calendar'
                                                                                                                                                                                                                                                                                                                        | '15.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '15.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '15.circle'
                                                                                                                                                                                                                                                                                                                        | '15.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '15.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '15.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '15.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '15.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '15.square'
                                                                                                                                                                                                                                                                                                                        | '15.square.ar'
                                                                                                                                                                                                                                                                                                                        | '15.square.fill'
                                                                                                                                                                                                                                                                                                                        | '15.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '15.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '15.square.hi'
                                                                                                                                                                                                                                                                                                                        | '16.calendar'
                                                                                                                                                                                                                                                                                                                        | '16.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '16.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '16.circle'
                                                                                                                                                                                                                                                                                                                        | '16.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '16.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '16.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '16.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '16.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '16.square'
                                                                                                                                                                                                                                                                                                                        | '16.square.ar'
                                                                                                                                                                                                                                                                                                                        | '16.square.fill'
                                                                                                                                                                                                                                                                                                                        | '16.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '16.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '16.square.hi'
                                                                                                                                                                                                                                                                                                                        | '17.calendar'
                                                                                                                                                                                                                                                                                                                        | '17.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '17.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '17.circle'
                                                                                                                                                                                                                                                                                                                        | '17.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '17.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '17.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '17.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '17.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '17.square'
                                                                                                                                                                                                                                                                                                                        | '17.square.ar'
                                                                                                                                                                                                                                                                                                                        | '17.square.fill'
                                                                                                                                                                                                                                                                                                                        | '17.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '17.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '17.square.hi'
                                                                                                                                                                                                                                                                                                                        | '18.calendar'
                                                                                                                                                                                                                                                                                                                        | '18.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '18.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '18.circle'
                                                                                                                                                                                                                                                                                                                        | '18.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '18.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '18.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '18.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '18.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '18.square'
                                                                                                                                                                                                                                                                                                                        | '18.square.ar'
                                                                                                                                                                                                                                                                                                                        | '18.square.fill'
                                                                                                                                                                                                                                                                                                                        | '18.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '18.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '18.square.hi'
                                                                                                                                                                                                                                                                                                                        | '19.calendar'
                                                                                                                                                                                                                                                                                                                        | '19.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '19.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '19.circle'
                                                                                                                                                                                                                                                                                                                        | '19.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '19.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '19.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '19.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '19.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '19.square'
                                                                                                                                                                                                                                                                                                                        | '19.square.ar'
                                                                                                                                                                                                                                                                                                                        | '19.square.fill'
                                                                                                                                                                                                                                                                                                                        | '19.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '19.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '19.square.hi'
                                                                                                                                                                                                                                                                                                                        | '2.brakesignal'
                                                                                                                                                                                                                                                                                                                        | '2.calendar'
                                                                                                                                                                                                                                                                                                                        | '2.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '2.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '2.circle'
                                                                                                                                                                                                                                                                                                                        | '2.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '2.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '2.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '2.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '2.lane'
                                                                                                                                                                                                                                                                                                                        | '2.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '2.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '2.square'
                                                                                                                                                                                                                                                                                                                        | '2.square.ar'
                                                                                                                                                                                                                                                                                                                        | '2.square.fill'
                                                                                                                                                                                                                                                                                                                        | '2.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '2.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '2.square.hi'
                                                                                                                                                                                                                                                                                                                        | '20.calendar'
                                                                                                                                                                                                                                                                                                                        | '20.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '20.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '20.circle'
                                                                                                                                                                                                                                                                                                                        | '20.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '20.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '20.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '20.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '20.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '20.square'
                                                                                                                                                                                                                                                                                                                        | '20.square.ar'
                                                                                                                                                                                                                                                                                                                        | '20.square.fill'
                                                                                                                                                                                                                                                                                                                        | '20.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '20.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '20.square.hi'
                                                                                                                                                                                                                                                                                                                        | '21.calendar'
                                                                                                                                                                                                                                                                                                                        | '21.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '21.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '21.circle'
                                                                                                                                                                                                                                                                                                                        | '21.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '21.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '21.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '21.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '21.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '21.square'
                                                                                                                                                                                                                                                                                                                        | '21.square.ar'
                                                                                                                                                                                                                                                                                                                        | '21.square.fill'
                                                                                                                                                                                                                                                                                                                        | '21.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '21.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '21.square.hi'
                                                                                                                                                                                                                                                                                                                        | '22.calendar'
                                                                                                                                                                                                                                                                                                                        | '22.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '22.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '22.circle'
                                                                                                                                                                                                                                                                                                                        | '22.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '22.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '22.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '22.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '22.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '22.square'
                                                                                                                                                                                                                                                                                                                        | '22.square.ar'
                                                                                                                                                                                                                                                                                                                        | '22.square.fill'
                                                                                                                                                                                                                                                                                                                        | '22.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '22.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '22.square.hi'
                                                                                                                                                                                                                                                                                                                        | '23.calendar'
                                                                                                                                                                                                                                                                                                                        | '23.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '23.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '23.circle'
                                                                                                                                                                                                                                                                                                                        | '23.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '23.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '23.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '23.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '23.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '23.square'
                                                                                                                                                                                                                                                                                                                        | '23.square.ar'
                                                                                                                                                                                                                                                                                                                        | '23.square.fill'
                                                                                                                                                                                                                                                                                                                        | '23.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '23.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '23.square.hi'
                                                                                                                                                                                                                                                                                                                        | '24.calendar'
                                                                                                                                                                                                                                                                                                                        | '24.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '24.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '24.circle'
                                                                                                                                                                                                                                                                                                                        | '24.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '24.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '24.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '24.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '24.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '24.square'
                                                                                                                                                                                                                                                                                                                        | '24.square.ar'
                                                                                                                                                                                                                                                                                                                        | '24.square.fill'
                                                                                                                                                                                                                                                                                                                        | '24.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '24.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '24.square.hi'
                                                                                                                                                                                                                                                                                                                        | '25.calendar'
                                                                                                                                                                                                                                                                                                                        | '25.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '25.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '25.circle'
                                                                                                                                                                                                                                                                                                                        | '25.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '25.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '25.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '25.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '25.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '25.square'
                                                                                                                                                                                                                                                                                                                        | '25.square.ar'
                                                                                                                                                                                                                                                                                                                        | '25.square.fill'
                                                                                                                                                                                                                                                                                                                        | '25.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '25.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '25.square.hi'
                                                                                                                                                                                                                                                                                                                        | '26.calendar'
                                                                                                                                                                                                                                                                                                                        | '26.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '26.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '26.circle'
                                                                                                                                                                                                                                                                                                                        | '26.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '26.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '26.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '26.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '26.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '26.square'
                                                                                                                                                                                                                                                                                                                        | '26.square.ar'
                                                                                                                                                                                                                                                                                                                        | '26.square.fill'
                                                                                                                                                                                                                                                                                                                        | '26.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '26.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '26.square.hi'
                                                                                                                                                                                                                                                                                                                        | '27.calendar'
                                                                                                                                                                                                                                                                                                                        | '27.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '27.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '27.circle'
                                                                                                                                                                                                                                                                                                                        | '27.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '27.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '27.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '27.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '27.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '27.square'
                                                                                                                                                                                                                                                                                                                        | '27.square.ar'
                                                                                                                                                                                                                                                                                                                        | '27.square.fill'
                                                                                                                                                                                                                                                                                                                        | '27.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '27.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '27.square.hi'
                                                                                                                                                                                                                                                                                                                        | '28.calendar'
                                                                                                                                                                                                                                                                                                                        | '28.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '28.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '28.circle'
                                                                                                                                                                                                                                                                                                                        | '28.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '28.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '28.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '28.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '28.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '28.square'
                                                                                                                                                                                                                                                                                                                        | '28.square.ar'
                                                                                                                                                                                                                                                                                                                        | '28.square.fill'
                                                                                                                                                                                                                                                                                                                        | '28.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '28.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '28.square.hi'
                                                                                                                                                                                                                                                                                                                        | '29.calendar'
                                                                                                                                                                                                                                                                                                                        | '29.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '29.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '29.circle'
                                                                                                                                                                                                                                                                                                                        | '29.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '29.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '29.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '29.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '29.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '29.square'
                                                                                                                                                                                                                                                                                                                        | '29.square.ar'
                                                                                                                                                                                                                                                                                                                        | '29.square.fill'
                                                                                                                                                                                                                                                                                                                        | '29.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '29.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '29.square.hi'
                                                                                                                                                                                                                                                                                                                        | '2h'
                                                                                                                                                                                                                                                                                                                        | '2h.circle'
                                                                                                                                                                                                                                                                                                                        | '2h.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '3.calendar'
                                                                                                                                                                                                                                                                                                                        | '3.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '3.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '3.circle'
                                                                                                                                                                                                                                                                                                                        | '3.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '3.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '3.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '3.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '3.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '3.lane'
                                                                                                                                                                                                                                                                                                                        | '3.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '3.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '3.square'
                                                                                                                                                                                                                                                                                                                        | '3.square.ar'
                                                                                                                                                                                                                                                                                                                        | '3.square.fill'
                                                                                                                                                                                                                                                                                                                        | '3.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '3.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '3.square.hi'
                                                                                                                                                                                                                                                                                                                        | '30.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | '30.arrow.trianglehead.clockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '30.arrow.trianglehead.clockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '30.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | '30.arrow.trianglehead.counterclockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '30.arrow.trianglehead.counterclockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '30.calendar'
                                                                                                                                                                                                                                                                                                                        | '30.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '30.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '30.circle'
                                                                                                                                                                                                                                                                                                                        | '30.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '30.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '30.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '30.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '30.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '30.square'
                                                                                                                                                                                                                                                                                                                        | '30.square.ar'
                                                                                                                                                                                                                                                                                                                        | '30.square.fill'
                                                                                                                                                                                                                                                                                                                        | '30.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '30.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '30.square.hi'
                                                                                                                                                                                                                                                                                                                        | '31.calendar'
                                                                                                                                                                                                                                                                                                                        | '31.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '31.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '31.circle'
                                                                                                                                                                                                                                                                                                                        | '31.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '31.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '31.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '31.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '31.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '31.square'
                                                                                                                                                                                                                                                                                                                        | '31.square.ar'
                                                                                                                                                                                                                                                                                                                        | '31.square.fill'
                                                                                                                                                                                                                                                                                                                        | '31.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '31.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '31.square.hi'
                                                                                                                                                                                                                                                                                                                        | '32.circle'
                                                                                                                                                                                                                                                                                                                        | '32.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '32.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '32.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '32.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '32.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '32.square'
                                                                                                                                                                                                                                                                                                                        | '32.square.ar'
                                                                                                                                                                                                                                                                                                                        | '32.square.fill'
                                                                                                                                                                                                                                                                                                                        | '32.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '32.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '32.square.hi'
                                                                                                                                                                                                                                                                                                                        | '33.circle'
                                                                                                                                                                                                                                                                                                                        | '33.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '33.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '33.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '33.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '33.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '33.square'
                                                                                                                                                                                                                                                                                                                        | '33.square.ar'
                                                                                                                                                                                                                                                                                                                        | '33.square.fill'
                                                                                                                                                                                                                                                                                                                        | '33.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '33.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '33.square.hi'
                                                                                                                                                                                                                                                                                                                        | '34.circle'
                                                                                                                                                                                                                                                                                                                        | '34.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '34.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '34.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '34.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '34.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '34.square'
                                                                                                                                                                                                                                                                                                                        | '34.square.ar'
                                                                                                                                                                                                                                                                                                                        | '34.square.fill'
                                                                                                                                                                                                                                                                                                                        | '34.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '34.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '34.square.hi'
                                                                                                                                                                                                                                                                                                                        | '35.circle'
                                                                                                                                                                                                                                                                                                                        | '35.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '35.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '35.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '35.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '35.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '35.square'
                                                                                                                                                                                                                                                                                                                        | '35.square.ar'
                                                                                                                                                                                                                                                                                                                        | '35.square.fill'
                                                                                                                                                                                                                                                                                                                        | '35.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '35.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '35.square.hi'
                                                                                                                                                                                                                                                                                                                        | '36.circle'
                                                                                                                                                                                                                                                                                                                        | '36.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '36.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '36.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '36.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '36.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '36.square'
                                                                                                                                                                                                                                                                                                                        | '36.square.ar'
                                                                                                                                                                                                                                                                                                                        | '36.square.fill'
                                                                                                                                                                                                                                                                                                                        | '36.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '36.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '36.square.hi'
                                                                                                                                                                                                                                                                                                                        | '37.circle'
                                                                                                                                                                                                                                                                                                                        | '37.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '37.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '37.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '37.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '37.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '37.square'
                                                                                                                                                                                                                                                                                                                        | '37.square.ar'
                                                                                                                                                                                                                                                                                                                        | '37.square.fill'
                                                                                                                                                                                                                                                                                                                        | '37.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '37.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '37.square.hi'
                                                                                                                                                                                                                                                                                                                        | '38.circle'
                                                                                                                                                                                                                                                                                                                        | '38.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '38.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '38.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '38.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '38.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '38.square'
                                                                                                                                                                                                                                                                                                                        | '38.square.ar'
                                                                                                                                                                                                                                                                                                                        | '38.square.fill'
                                                                                                                                                                                                                                                                                                                        | '38.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '38.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '38.square.hi'
                                                                                                                                                                                                                                                                                                                        | '39.circle'
                                                                                                                                                                                                                                                                                                                        | '39.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '39.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '39.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '39.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '39.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '39.square'
                                                                                                                                                                                                                                                                                                                        | '39.square.ar'
                                                                                                                                                                                                                                                                                                                        | '39.square.fill'
                                                                                                                                                                                                                                                                                                                        | '39.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '39.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '39.square.hi'
                                                                                                                                                                                                                                                                                                                        | '4.alt.circle'
                                                                                                                                                                                                                                                                                                                        | '4.alt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '4.alt.square'
                                                                                                                                                                                                                                                                                                                        | '4.alt.square.fill'
                                                                                                                                                                                                                                                                                                                        | '4.calendar'
                                                                                                                                                                                                                                                                                                                        | '4.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '4.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '4.circle'
                                                                                                                                                                                                                                                                                                                        | '4.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '4.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '4.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '4.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '4.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '4.lane'
                                                                                                                                                                                                                                                                                                                        | '4.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '4.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '4.square'
                                                                                                                                                                                                                                                                                                                        | '4.square.ar'
                                                                                                                                                                                                                                                                                                                        | '4.square.fill'
                                                                                                                                                                                                                                                                                                                        | '4.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '4.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '4.square.hi'
                                                                                                                                                                                                                                                                                                                        | '40.circle'
                                                                                                                                                                                                                                                                                                                        | '40.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '40.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '40.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '40.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '40.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '40.square'
                                                                                                                                                                                                                                                                                                                        | '40.square.ar'
                                                                                                                                                                                                                                                                                                                        | '40.square.fill'
                                                                                                                                                                                                                                                                                                                        | '40.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '40.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '40.square.hi'
                                                                                                                                                                                                                                                                                                                        | '41.circle'
                                                                                                                                                                                                                                                                                                                        | '41.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '41.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '41.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '41.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '41.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '41.square'
                                                                                                                                                                                                                                                                                                                        | '41.square.ar'
                                                                                                                                                                                                                                                                                                                        | '41.square.fill'
                                                                                                                                                                                                                                                                                                                        | '41.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '41.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '41.square.hi'
                                                                                                                                                                                                                                                                                                                        | '42.circle'
                                                                                                                                                                                                                                                                                                                        | '42.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '42.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '42.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '42.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '42.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '42.square'
                                                                                                                                                                                                                                                                                                                        | '42.square.ar'
                                                                                                                                                                                                                                                                                                                        | '42.square.fill'
                                                                                                                                                                                                                                                                                                                        | '42.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '42.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '42.square.hi'
                                                                                                                                                                                                                                                                                                                        | '43.circle'
                                                                                                                                                                                                                                                                                                                        | '43.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '43.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '43.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '43.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '43.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '43.square'
                                                                                                                                                                                                                                                                                                                        | '43.square.ar'
                                                                                                                                                                                                                                                                                                                        | '43.square.fill'
                                                                                                                                                                                                                                                                                                                        | '43.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '43.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '43.square.hi'
                                                                                                                                                                                                                                                                                                                        | '44.circle'
                                                                                                                                                                                                                                                                                                                        | '44.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '44.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '44.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '44.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '44.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '44.square'
                                                                                                                                                                                                                                                                                                                        | '44.square.ar'
                                                                                                                                                                                                                                                                                                                        | '44.square.fill'
                                                                                                                                                                                                                                                                                                                        | '44.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '44.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '44.square.hi'
                                                                                                                                                                                                                                                                                                                        | '45.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | '45.arrow.trianglehead.clockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '45.arrow.trianglehead.clockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '45.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | '45.arrow.trianglehead.counterclockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '45.arrow.trianglehead.counterclockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '45.circle'
                                                                                                                                                                                                                                                                                                                        | '45.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '45.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '45.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '45.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '45.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '45.square'
                                                                                                                                                                                                                                                                                                                        | '45.square.ar'
                                                                                                                                                                                                                                                                                                                        | '45.square.fill'
                                                                                                                                                                                                                                                                                                                        | '45.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '45.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '45.square.hi'
                                                                                                                                                                                                                                                                                                                        | '46.circle'
                                                                                                                                                                                                                                                                                                                        | '46.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '46.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '46.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '46.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '46.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '46.square'
                                                                                                                                                                                                                                                                                                                        | '46.square.ar'
                                                                                                                                                                                                                                                                                                                        | '46.square.fill'
                                                                                                                                                                                                                                                                                                                        | '46.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '46.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '46.square.hi'
                                                                                                                                                                                                                                                                                                                        | '47.circle'
                                                                                                                                                                                                                                                                                                                        | '47.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '47.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '47.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '47.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '47.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '47.square'
                                                                                                                                                                                                                                                                                                                        | '47.square.ar'
                                                                                                                                                                                                                                                                                                                        | '47.square.fill'
                                                                                                                                                                                                                                                                                                                        | '47.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '47.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '47.square.hi'
                                                                                                                                                                                                                                                                                                                        | '48.circle'
                                                                                                                                                                                                                                                                                                                        | '48.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '48.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '48.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '48.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '48.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '48.square'
                                                                                                                                                                                                                                                                                                                        | '48.square.ar'
                                                                                                                                                                                                                                                                                                                        | '48.square.fill'
                                                                                                                                                                                                                                                                                                                        | '48.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '48.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '48.square.hi'
                                                                                                                                                                                                                                                                                                                        | '49.circle'
                                                                                                                                                                                                                                                                                                                        | '49.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '49.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '49.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '49.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '49.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '49.square'
                                                                                                                                                                                                                                                                                                                        | '49.square.ar'
                                                                                                                                                                                                                                                                                                                        | '49.square.fill'
                                                                                                                                                                                                                                                                                                                        | '49.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '49.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '49.square.hi'
                                                                                                                                                                                                                                                                                                                        | '4a'
                                                                                                                                                                                                                                                                                                                        | '4a.circle'
                                                                                                                                                                                                                                                                                                                        | '4a.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '4h'
                                                                                                                                                                                                                                                                                                                        | '4h.circle'
                                                                                                                                                                                                                                                                                                                        | '4h.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '4k.tv'
                                                                                                                                                                                                                                                                                                                        | '4k.tv.fill'
                                                                                                                                                                                                                                                                                                                        | '4l'
                                                                                                                                                                                                                                                                                                                        | '4l.circle'
                                                                                                                                                                                                                                                                                                                        | '4l.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '5.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | '5.arrow.trianglehead.clockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '5.arrow.trianglehead.clockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '5.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | '5.arrow.trianglehead.counterclockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '5.arrow.trianglehead.counterclockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '5.calendar'
                                                                                                                                                                                                                                                                                                                        | '5.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '5.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '5.circle'
                                                                                                                                                                                                                                                                                                                        | '5.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '5.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '5.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '5.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '5.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '5.lane'
                                                                                                                                                                                                                                                                                                                        | '5.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '5.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '5.square'
                                                                                                                                                                                                                                                                                                                        | '5.square.ar'
                                                                                                                                                                                                                                                                                                                        | '5.square.fill'
                                                                                                                                                                                                                                                                                                                        | '5.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '5.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '5.square.hi'
                                                                                                                                                                                                                                                                                                                        | '50.circle'
                                                                                                                                                                                                                                                                                                                        | '50.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '50.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '50.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '50.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '50.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '50.square'
                                                                                                                                                                                                                                                                                                                        | '50.square.ar'
                                                                                                                                                                                                                                                                                                                        | '50.square.fill'
                                                                                                                                                                                                                                                                                                                        | '50.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '50.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '50.square.hi'
                                                                                                                                                                                                                                                                                                                        | '6.alt.circle'
                                                                                                                                                                                                                                                                                                                        | '6.alt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '6.alt.square'
                                                                                                                                                                                                                                                                                                                        | '6.alt.square.fill'
                                                                                                                                                                                                                                                                                                                        | '6.calendar'
                                                                                                                                                                                                                                                                                                                        | '6.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '6.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '6.circle'
                                                                                                                                                                                                                                                                                                                        | '6.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '6.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '6.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '6.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '6.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '6.lane'
                                                                                                                                                                                                                                                                                                                        | '6.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '6.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '6.square'
                                                                                                                                                                                                                                                                                                                        | '6.square.ar'
                                                                                                                                                                                                                                                                                                                        | '6.square.fill'
                                                                                                                                                                                                                                                                                                                        | '6.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '6.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '6.square.hi'
                                                                                                                                                                                                                                                                                                                        | '60.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | '60.arrow.trianglehead.clockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '60.arrow.trianglehead.clockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '60.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | '60.arrow.trianglehead.counterclockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '60.arrow.trianglehead.counterclockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '7.calendar'
                                                                                                                                                                                                                                                                                                                        | '7.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '7.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '7.circle'
                                                                                                                                                                                                                                                                                                                        | '7.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '7.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '7.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '7.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '7.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '7.lane'
                                                                                                                                                                                                                                                                                                                        | '7.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '7.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '7.square'
                                                                                                                                                                                                                                                                                                                        | '7.square.ar'
                                                                                                                                                                                                                                                                                                                        | '7.square.fill'
                                                                                                                                                                                                                                                                                                                        | '7.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '7.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '7.square.hi'
                                                                                                                                                                                                                                                                                                                        | '75.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | '75.arrow.trianglehead.clockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '75.arrow.trianglehead.clockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '75.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | '75.arrow.trianglehead.counterclockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '75.arrow.trianglehead.counterclockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '8.calendar'
                                                                                                                                                                                                                                                                                                                        | '8.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '8.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '8.circle'
                                                                                                                                                                                                                                                                                                                        | '8.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '8.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '8.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '8.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '8.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '8.lane'
                                                                                                                                                                                                                                                                                                                        | '8.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '8.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '8.square'
                                                                                                                                                                                                                                                                                                                        | '8.square.ar'
                                                                                                                                                                                                                                                                                                                        | '8.square.fill'
                                                                                                                                                                                                                                                                                                                        | '8.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '8.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '8.square.hi'
                                                                                                                                                                                                                                                                                                                        | '9.alt.circle'
                                                                                                                                                                                                                                                                                                                        | '9.alt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '9.alt.square'
                                                                                                                                                                                                                                                                                                                        | '9.alt.square.fill'
                                                                                                                                                                                                                                                                                                                        | '9.calendar'
                                                                                                                                                                                                                                                                                                                        | '9.calendar.ar'
                                                                                                                                                                                                                                                                                                                        | '9.calendar.hi'
                                                                                                                                                                                                                                                                                                                        | '9.circle'
                                                                                                                                                                                                                                                                                                                        | '9.circle.ar'
                                                                                                                                                                                                                                                                                                                        | '9.circle.fill'
                                                                                                                                                                                                                                                                                                                        | '9.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '9.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '9.circle.hi'
                                                                                                                                                                                                                                                                                                                        | '9.lane'
                                                                                                                                                                                                                                                                                                                        | '9.lane.ar'
                                                                                                                                                                                                                                                                                                                        | '9.lane.hi'
                                                                                                                                                                                                                                                                                                                        | '9.square'
                                                                                                                                                                                                                                                                                                                        | '9.square.ar'
                                                                                                                                                                                                                                                                                                                        | '9.square.fill'
                                                                                                                                                                                                                                                                                                                        | '9.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | '9.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | '9.square.hi'
                                                                                                                                                                                                                                                                                                                        | '90.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | '90.arrow.trianglehead.clockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '90.arrow.trianglehead.clockwise.hi'
                                                                                                                                                                                                                                                                                                                        | '90.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | '90.arrow.trianglehead.counterclockwise.ar'
                                                                                                                                                                                                                                                                                                                        | '90.arrow.trianglehead.counterclockwise.hi'
                                                                                                                                                                                                                                                                                                                        | 'a'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.ar'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.fill'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.fill.he'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.fill.hi'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.fill.ja'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.fill.ko'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.fill.th'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.fill.zh'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.he'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.hi'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.ja'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.ko'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.th'
                                                                                                                                                                                                                                                                                                                        | 'a.book.closed.zh'
                                                                                                                                                                                                                                                                                                                        | 'a.circle'
                                                                                                                                                                                                                                                                                                                        | 'a.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'a.magnify'
                                                                                                                                                                                                                                                                                                                        | 'a.square'
                                                                                                                                                                                                                                                                                                                        | 'a.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'abc'
                                                                                                                                                                                                                                                                                                                        | 'abs'
                                                                                                                                                                                                                                                                                                                        | 'abs.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'abs.brakesignal.slash'
                                                                                                                                                                                                                                                                                                                        | 'abs.circle'
                                                                                                                                                                                                                                                                                                                        | 'abs.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'ac'
                                                                                                                                                                                                                                                                                                                        | 'ac.slash'
                                                                                                                                                                                                                                                                                                                        | 'accessibility'
                                                                                                                                                                                                                                                                                                                        | 'accessibility.badge.arrow.up.right'
                                                                                                                                                                                                                                                                                                                        | 'accessibility.fill'
                                                                                                                                                                                                                                                                                                                        | 'air.car.side'
                                                                                                                                                                                                                                                                                                                        | 'air.car.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'air.conditioner'
                                                                                                                                                                                                                                                                                                                        | 'air.conditioner.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'air.conditioner.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'air.conditioner.slash'
                                                                                                                                                                                                                                                                                                                        | 'air.conditioner.vertical'
                                                                                                                                                                                                                                                                                                                        | 'air.conditioner.vertical.fill'
                                                                                                                                                                                                                                                                                                                        | 'air.convertible.side'
                                                                                                                                                                                                                                                                                                                        | 'air.convertible.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'air.pickup.side'
                                                                                                                                                                                                                                                                                                                        | 'air.pickup.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'air.purifier'
                                                                                                                                                                                                                                                                                                                        | 'air.purifier.fill'
                                                                                                                                                                                                                                                                                                                        | 'air.suv.side'
                                                                                                                                                                                                                                                                                                                        | 'air.suv.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'airplane'
                                                                                                                                                                                                                                                                                                                        | 'airplane.arrival'
                                                                                                                                                                                                                                                                                                                        | 'airplane.circle'
                                                                                                                                                                                                                                                                                                                        | 'airplane.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'airplane.cloud'
                                                                                                                                                                                                                                                                                                                        | 'airplane.departure'
                                                                                                                                                                                                                                                                                                                        | 'airplane.landed'
                                                                                                                                                                                                                                                                                                                        | 'airplane.path.dotted'
                                                                                                                                                                                                                                                                                                                        | 'airplane.ticket'
                                                                                                                                                                                                                                                                                                                        | 'airplane.ticket.fill'
                                                                                                                                                                                                                                                                                                                        | 'airplane.up.forward'
                                                                                                                                                                                                                                                                                                                        | 'airplane.up.forward.app'
                                                                                                                                                                                                                                                                                                                        | 'airplane.up.forward.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'airplane.up.right'
                                                                                                                                                                                                                                                                                                                        | 'airplane.up.right.app'
                                                                                                                                                                                                                                                                                                                        | 'airplane.up.right.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'airplaneseat'
                                                                                                                                                                                                                                                                                                                        | 'airplay.audio'
                                                                                                                                                                                                                                                                                                                        | 'airplay.audio.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'airplay.audio.circle'
                                                                                                                                                                                                                                                                                                                        | 'airplay.audio.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'airplay.video'
                                                                                                                                                                                                                                                                                                                        | 'airplay.video.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'airplay.video.circle'
                                                                                                                                                                                                                                                                                                                        | 'airplay.video.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'airplayaudio'
                                                                                                                                                                                                                                                                                                                        | 'airplayaudio.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'airplayaudio.circle'
                                                                                                                                                                                                                                                                                                                        | 'airplayaudio.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'airplayvideo'
                                                                                                                                                                                                                                                                                                                        | 'airplayvideo.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'airplayvideo.circle'
                                                                                                                                                                                                                                                                                                                        | 'airplayvideo.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpod.gen3.left'
                                                                                                                                                                                                                                                                                                                        | 'airpod.gen3.right'
                                                                                                                                                                                                                                                                                                                        | 'airpod.left'
                                                                                                                                                                                                                                                                                                                        | 'airpod.right'
                                                                                                                                                                                                                                                                                                                        | 'airpodpro.left'
                                                                                                                                                                                                                                                                                                                        | 'airpodpro.right'
                                                                                                                                                                                                                                                                                                                        | 'airpods'
                                                                                                                                                                                                                                                                                                                        | 'airpods.chargingcase'
                                                                                                                                                                                                                                                                                                                        | 'airpods.chargingcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpods.chargingcase.wireless'
                                                                                                                                                                                                                                                                                                                        | 'airpods.chargingcase.wireless.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpods.gen3'
                                                                                                                                                                                                                                                                                                                        | 'airpods.gen3.chargingcase.wireless'
                                                                                                                                                                                                                                                                                                                        | 'airpods.gen3.chargingcase.wireless.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpods.gen4'
                                                                                                                                                                                                                                                                                                                        | 'airpods.gen4.chargingcase.wireless'
                                                                                                                                                                                                                                                                                                                        | 'airpods.gen4.chargingcase.wireless.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpods.gen4.left'
                                                                                                                                                                                                                                                                                                                        | 'airpods.gen4.right'
                                                                                                                                                                                                                                                                                                                        | 'airpods.max'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.chargingcase.wireless'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.chargingcase.wireless.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.chargingcase.wireless.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.chargingcase.wireless.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen1'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen1.chargingcase.wireless'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen1.chargingcase.wireless.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen1.chargingcase.wireless.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen1.chargingcase.wireless.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen1.left'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen1.right'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen3'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen3.chargingcase.wireless'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen3.chargingcase.wireless.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen3.chargingcase.wireless.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen3.chargingcase.wireless.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen3.left'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.gen3.right'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.left'
                                                                                                                                                                                                                                                                                                                        | 'airpods.pro.right'
                                                                                                                                                                                                                                                                                                                        | 'airpodsmax'
                                                                                                                                                                                                                                                                                                                        | 'airpodspro'
                                                                                                                                                                                                                                                                                                                        | 'airpodspro.chargingcase.wireless'
                                                                                                                                                                                                                                                                                                                        | 'airpodspro.chargingcase.wireless.fill'
                                                                                                                                                                                                                                                                                                                        | 'airpodspro.chargingcase.wireless.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'airpodspro.chargingcase.wireless.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'airport.express'
                                                                                                                                                                                                                                                                                                                        | 'airport.extreme'
                                                                                                                                                                                                                                                                                                                        | 'airport.extreme.tower'
                                                                                                                                                                                                                                                                                                                        | 'airtag'
                                                                                                                                                                                                                                                                                                                        | 'airtag.fill'
                                                                                                                                                                                                                                                                                                                        | 'airtag.radiowaves.forward'
                                                                                                                                                                                                                                                                                                                        | 'airtag.radiowaves.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'airtag.radiowaves.forward.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'airtag.radiowaves.forward.rtl'
                                                                                                                                                                                                                                                                                                                        | 'alarm'
                                                                                                                                                                                                                                                                                                                        | 'alarm.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'alarm.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'alarm.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'alarm.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'alarm.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'alarm.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'alarm.fill'
                                                                                                                                                                                                                                                                                                                        | 'alarm.slash'
                                                                                                                                                                                                                                                                                                                        | 'alarm.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'alarm.waves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'alarm.waves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'align.horizontal.center'
                                                                                                                                                                                                                                                                                                                        | 'align.horizontal.center.fill'
                                                                                                                                                                                                                                                                                                                        | 'align.horizontal.left'
                                                                                                                                                                                                                                                                                                                        | 'align.horizontal.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'align.horizontal.right'
                                                                                                                                                                                                                                                                                                                        | 'align.horizontal.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'align.vertical.bottom'
                                                                                                                                                                                                                                                                                                                        | 'align.vertical.bottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'align.vertical.center'
                                                                                                                                                                                                                                                                                                                        | 'align.vertical.center.fill'
                                                                                                                                                                                                                                                                                                                        | 'align.vertical.top'
                                                                                                                                                                                                                                                                                                                        | 'align.vertical.top.fill'
                                                                                                                                                                                                                                                                                                                        | 'allergens'
                                                                                                                                                                                                                                                                                                                        | 'allergens.fill'
                                                                                                                                                                                                                                                                                                                        | 'alt'
                                                                                                                                                                                                                                                                                                                        | 'alternatingcurrent'
                                                                                                                                                                                                                                                                                                                        | 'american.football'
                                                                                                                                                                                                                                                                                                                        | 'american.football.circle'
                                                                                                                                                                                                                                                                                                                        | 'american.football.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'american.football.fill'
                                                                                                                                                                                                                                                                                                                        | 'american.football.professional'
                                                                                                                                                                                                                                                                                                                        | 'american.football.professional.circle'
                                                                                                                                                                                                                                                                                                                        | 'american.football.professional.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'american.football.professional.fill'
                                                                                                                                                                                                                                                                                                                        | 'amplifier'
                                                                                                                                                                                                                                                                                                                        | 'angle'
                                                                                                                                                                                                                                                                                                                        | 'ant'
                                                                                                                                                                                                                                                                                                                        | 'ant.circle'
                                                                                                                                                                                                                                                                                                                        | 'ant.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'ant.fill'
                                                                                                                                                                                                                                                                                                                        | 'antenna.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'antenna.radiowaves.left.and.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'antenna.radiowaves.left.and.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'antenna.radiowaves.left.and.right.slash'
                                                                                                                                                                                                                                                                                                                        | 'antenna.radiowaves.left.and.right.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'antenna.radiowaves.left.and.right.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'app'
                                                                                                                                                                                                                                                                                                                        | 'app.background.dotted'
                                                                                                                                                                                                                                                                                                                        | 'app.badge'
                                                                                                                                                                                                                                                                                                                        | 'app.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'app.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'app.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.badge.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.connected.to.app.below.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.dashed'
                                                                                                                                                                                                                                                                                                                        | 'app.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.gift'
                                                                                                                                                                                                                                                                                                                        | 'app.gift.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.grid'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2.and.person.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2.bottom.dashed'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2.bottom.dashed.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2.topleading.dashed'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2.topleading.dashed.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2.topleading.filled'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2.topleft.dashed'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2.topleft.dashed.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.grid.2x2.topleft.filled'
                                                                                                                                                                                                                                                                                                                        | 'app.shadow'
                                                                                                                                                                                                                                                                                                                        | 'app.slash'
                                                                                                                                                                                                                                                                                                                        | 'app.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'app.specular'
                                                                                                                                                                                                                                                                                                                        | 'app.translucent'
                                                                                                                                                                                                                                                                                                                        | 'appclip'
                                                                                                                                                                                                                                                                                                                        | 'append.page'
                                                                                                                                                                                                                                                                                                                        | 'append.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'append.page.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'append.page.rtl'
                                                                                                                                                                                                                                                                                                                        | 'apple.books.pages'
                                                                                                                                                                                                                                                                                                                        | 'apple.books.pages.fill'
                                                                                                                                                                                                                                                                                                                        | 'apple.classical.pages'
                                                                                                                                                                                                                                                                                                                        | 'apple.classical.pages.fill'
                                                                                                                                                                                                                                                                                                                        | 'apple.haptics.and.exclamationmark.triangle'
                                                                                                                                                                                                                                                                                                                        | 'apple.haptics.and.music.note'
                                                                                                                                                                                                                                                                                                                        | 'apple.haptics.and.music.note.slash'
                                                                                                                                                                                                                                                                                                                        | 'apple.homekit'
                                                                                                                                                                                                                                                                                                                        | 'apple.image.playground'
                                                                                                                                                                                                                                                                                                                        | 'apple.image.playground.fill'
                                                                                                                                                                                                                                                                                                                        | 'apple.intelligence'
                                                                                                                                                                                                                                                                                                                        | 'apple.intelligence.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'apple.logo'
                                                                                                                                                                                                                                                                                                                        | 'apple.meditate'
                                                                                                                                                                                                                                                                                                                        | 'apple.meditate.circle'
                                                                                                                                                                                                                                                                                                                        | 'apple.meditate.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'apple.meditate.square.stack'
                                                                                                                                                                                                                                                                                                                        | 'apple.meditate.square.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'apple.podcasts.pages'
                                                                                                                                                                                                                                                                                                                        | 'apple.podcasts.pages.fill'
                                                                                                                                                                                                                                                                                                                        | 'apple.terminal'
                                                                                                                                                                                                                                                                                                                        | 'apple.terminal.circle'
                                                                                                                                                                                                                                                                                                                        | 'apple.terminal.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'apple.terminal.fill'
                                                                                                                                                                                                                                                                                                                        | 'apple.terminal.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'apple.terminal.on.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'apple.writing.tools'
                                                                                                                                                                                                                                                                                                                        | 'applelogo'
                                                                                                                                                                                                                                                                                                                        | 'applepencil'
                                                                                                                                                                                                                                                                                                                        | 'applepencil.adapter.usb.c'
                                                                                                                                                                                                                                                                                                                        | 'applepencil.adapter.usb.c.fill'
                                                                                                                                                                                                                                                                                                                        | 'applepencil.and.scribble'
                                                                                                                                                                                                                                                                                                                        | 'applepencil.doubletap'
                                                                                                                                                                                                                                                                                                                        | 'applepencil.gen1'
                                                                                                                                                                                                                                                                                                                        | 'applepencil.gen2'
                                                                                                                                                                                                                                                                                                                        | 'applepencil.hover'
                                                                                                                                                                                                                                                                                                                        | 'applepencil.squeeze'
                                                                                                                                                                                                                                                                                                                        | 'applepencil.tip'
                                                                                                                                                                                                                                                                                                                        | 'applescript'
                                                                                                                                                                                                                                                                                                                        | 'applescript.fill'
                                                                                                                                                                                                                                                                                                                        | 'appletv'
                                                                                                                                                                                                                                                                                                                        | 'appletv.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'appletv.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'appletv.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'appletv.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'appletv.fill'
                                                                                                                                                                                                                                                                                                                        | 'appletvremote.gen1'
                                                                                                                                                                                                                                                                                                                        | 'appletvremote.gen1.fill'
                                                                                                                                                                                                                                                                                                                        | 'appletvremote.gen2'
                                                                                                                                                                                                                                                                                                                        | 'appletvremote.gen2.fill'
                                                                                                                                                                                                                                                                                                                        | 'appletvremote.gen3'
                                                                                                                                                                                                                                                                                                                        | 'appletvremote.gen3.fill'
                                                                                                                                                                                                                                                                                                                        | 'appletvremote.gen4'
                                                                                                                                                                                                                                                                                                                        | 'appletvremote.gen4.fill'
                                                                                                                                                                                                                                                                                                                        | 'applewatch'
                                                                                                                                                                                                                                                                                                                        | 'applewatch.and.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'applewatch.and.arrow.forward.rtl'
                                                                                                                                                                                                                                                                                                                        | 'applewatch.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'applewatch.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'applewatch.case.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'applewatch.case.sizes'
                                                                                                                                                                                                                                                                                                                        | 'applewatch.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'applewatch.side.right'
                                                                                                                                                                                                                                                                                                                        | 'applewatch.slash'
                                                                                                                                                                                                                                                                                                                        | 'applewatch.watchface'
                                                                                                                                                                                                                                                                                                                        | 'apps.ipad'
                                                                                                                                                                                                                                                                                                                        | 'apps.ipad.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'apps.ipad.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'apps.ipad.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'apps.ipad.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'apps.ipad.landscape'
                                                                                                                                                                                                                                                                                                                        | 'apps.ipad.on.rectangle.portrait.dashed'
                                                                                                                                                                                                                                                                                                                        | 'apps.ipad.on.rectangle.portrait.dashed.rtl'
                                                                                                                                                                                                                                                                                                                        | 'apps.iphone'
                                                                                                                                                                                                                                                                                                                        | 'apps.iphone.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'apps.iphone.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'apps.iphone.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'apps.iphone.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'apps.iphone.landscape'
                                                                                                                                                                                                                                                                                                                        | 'apps.iphone.landscape.rtl'
                                                                                                                                                                                                                                                                                                                        | 'appwindow.swipe.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'aqi.high'
                                                                                                                                                                                                                                                                                                                        | 'aqi.low'
                                                                                                                                                                                                                                                                                                                        | 'aqi.medium'
                                                                                                                                                                                                                                                                                                                        | 'aqi.medium.gauge.open'
                                                                                                                                                                                                                                                                                                                        | 'arcade.stick'
                                                                                                                                                                                                                                                                                                                        | 'arcade.stick.and.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'arcade.stick.and.arrow.left'
                                                                                                                                                                                                                                                                                                                        | 'arcade.stick.and.arrow.left.and.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'arcade.stick.and.arrow.left.and.arrow.right.outward'
                                                                                                                                                                                                                                                                                                                        | 'arcade.stick.and.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'arcade.stick.and.arrow.up'
                                                                                                                                                                                                                                                                                                                        | 'arcade.stick.and.arrow.up.and.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'arcade.stick.console'
                                                                                                                                                                                                                                                                                                                        | 'arcade.stick.console.fill'
                                                                                                                                                                                                                                                                                                                        | 'archivebox'
                                                                                                                                                                                                                                                                                                                        | 'archivebox.circle'
                                                                                                                                                                                                                                                                                                                        | 'archivebox.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'archivebox.fill'
                                                                                                                                                                                                                                                                                                                        | 'arkit'
                                                                                                                                                                                                                                                                                                                        | 'arkit.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'arrow.2.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'arrow.2.circlepath.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.2.circlepath.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.2.squarepath'
                                                                                                                                                                                                                                                                                                                        | 'arrow.3.trianglepath'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.to.line'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.to.line.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.to.line.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.to.line.compact'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.to.line.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.backward.to.line.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.branch'
                                                                                                                                                                                                                                                                                                                        | 'arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'arrow.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'arrow.clockwise.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.clockwise.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.clockwise.heart'
                                                                                                                                                                                                                                                                                                                        | 'arrow.clockwise.heart.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.clockwise.icloud'
                                                                                                                                                                                                                                                                                                                        | 'arrow.clockwise.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.clockwise.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.clockwise.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | 'arrow.counterclockwise.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.counterclockwise.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.counterclockwise.icloud'
                                                                                                                                                                                                                                                                                                                        | 'arrow.counterclockwise.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.counterclockwise.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.counterclockwise.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.and.line.horizontal.and.arrow.up'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.app'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.app.dashed'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.app.dashed.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.applewatch'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.and.arrow.up.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.and.arrow.up.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.and.arrow.up.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.and.arrow.up.forward.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.and.arrow.up.forward.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.and.arrow.up.forward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.and.arrow.up.forward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.toptrailing.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.backward.toptrailing.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.circle.badge.pause'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.circle.badge.pause.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.circle.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.circle.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.doc'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.doc.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.document'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.document.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.and.arrow.up.backward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.and.arrow.up.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.and.arrow.up.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.and.arrow.up.backward.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.and.arrow.up.backward.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.and.arrow.up.backward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.and.arrow.up.backward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.topleading.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.forward.topleading.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.heart'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.heart.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.and.arrow.up.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.and.arrow.up.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.and.arrow.up.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.and.arrow.up.right.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.and.arrow.up.right.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.and.arrow.up.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.and.arrow.up.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.arrow.up.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.arrow.up.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.arrow.up.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.arrow.up.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.arrow.up.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.topright.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.topright.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.video'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.left.video.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.message'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.message.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.and.arrow.up.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.and.arrow.up.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.and.arrow.up.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.and.arrow.up.left.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.and.arrow.up.left.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.and.arrow.up.left.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.and.arrow.up.left.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.topleft.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.right.topleft.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.to.line'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.to.line.alt'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.to.line.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.to.line.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.to.line.compact'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.to.line.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.down.to.line.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.folder'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.folder.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.folder.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.folder.rtl'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.to.line'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.to.line.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.to.line.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.to.line.compact'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.to.line.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.forward.to.line.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.and.line.vertical.and.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.and.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.and.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.and.right.righttriangle.left.righttriangle.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.and.right.righttriangle.left.righttriangle.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.and.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.and.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.and.right.text.vertical'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.arrow.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.arrow.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.arrow.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.arrow.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.to.line'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.to.line.alt'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.to.line.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.to.line.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.to.line.compact'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.to.line.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.left.to.line.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.merge'
                                                                                                                                                                                                                                                                                                                        | 'arrow.rectanglepath'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.and.line.vertical.and.arrow.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.arrow.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.arrow.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.arrow.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.arrow.left.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.arrow.left.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.doc.on.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.filled.filter.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.page.on.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.to.line'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.to.line.alt'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.to.line.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.to.line.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.to.line.compact'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.to.line.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.right.to.line.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.swap'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.2.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.2.circlepath.camera'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.2.circlepath.camera.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.2.circlepath.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.2.circlepath.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.2.circlepath.doc.on.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.2.circlepath.icloud'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.2.circlepath.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.branch'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.capsulepath'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.merge'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.pull'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.swap'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.turn.up.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.turn.up.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.turn.up.right.diamond'
                                                                                                                                                                                                                                                                                                                        | 'arrow.triangle.turn.up.right.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.clockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.clockwise.rotate.90.camera'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.clockwise.rotate.90.camera.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.clockwise.rotate.90.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.clockwise.rotate.90.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.clockwise.rotate.90.icloud'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.clockwise.rotate.90.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.clockwise.rotate.90.page.on.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.2.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.bottomleft.capsulepath.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.branch'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.clockwise.heart'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.clockwise.heart.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.clockwise.icloud'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.clockwise.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.clockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.counterclockwise.icloud'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.counterclockwise.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.left.and.right.righttriangle.left.righttriangle.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.left.and.right.righttriangle.left.righttriangle.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.merge'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.pull'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.rectanglepath'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.swap'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.topright.capsulepath.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.turn.up.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.turn.up.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.turn.up.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.turn.up.right.diamond'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.turn.up.right.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.up.and.down.righttriangle.up.righttriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'arrow.trianglehead.up.and.down.righttriangle.up.righttriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.turn.down.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.turn.down.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.turn.left.down'
                                                                                                                                                                                                                                                                                                                        | 'arrow.turn.left.up'
                                                                                                                                                                                                                                                                                                                        | 'arrow.turn.right.down'
                                                                                                                                                                                                                                                                                                                        | 'arrow.turn.right.up'
                                                                                                                                                                                                                                                                                                                        | 'arrow.turn.up.forward.iphone'
                                                                                                                                                                                                                                                                                                                        | 'arrow.turn.up.forward.iphone.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.turn.up.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.turn.up.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down.and.arrow.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down.and.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down.righttriangle.up.fill.righttriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down.righttriangle.up.righttriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down.righttriangle.up.righttriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.down.text.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.line.horizontal.and.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.person.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.person.rectangle.turn.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.and.person.rectangle.turn.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.arrow.down.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.arrow.down.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.arrow.down.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.arrow.down.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.and.arrow.down.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.and.arrow.down.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.and.arrow.down.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.and.arrow.down.forward.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.and.arrow.down.forward.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.and.arrow.down.forward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.and.arrow.down.forward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.bottomtrailing.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.bottomtrailing.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.backward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.bin'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.bin.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.circle.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.doc'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.doc.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.doc.on.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.document'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.document.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.folder'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.folder.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.and.arrow.down.backward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.and.arrow.down.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.and.arrow.down.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.and.arrow.down.backward.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.and.arrow.down.backward.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.and.arrow.down.backward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.and.arrow.down.backward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.app'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.bottomleading.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.bottomleading.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.forward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.heart'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.heart.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.and.arrow.down.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.and.arrow.down.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.and.arrow.down.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.and.arrow.down.right.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.and.arrow.down.right.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.and.arrow.down.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.and.arrow.down.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.and.down.right.and.arrow.up.right.and.down.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.and.down.right.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.arrow.down.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.arrow.down.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.arrow.down.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.arrow.down.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.arrow.down.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.bottomright.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.bottomright.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.left.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.message'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.message.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.page.on.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.and.arrow.down.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.and.arrow.down.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.and.arrow.down.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.and.arrow.down.left.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.and.arrow.down.left.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.and.arrow.down.left.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.and.arrow.down.left.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.bottomleft.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.bottomleft.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.diamond'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.video'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.right.video.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.to.line'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.to.line.alt'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.to.line.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.to.line.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.to.line.compact'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.to.line.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.to.line.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.trash'
                                                                                                                                                                                                                                                                                                                        | 'arrow.up.trash.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.backward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.backward.circle.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.backward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.backward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.down'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.down.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.down.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.down.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.down.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.forward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.forward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.left'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.left.circle.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.left.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.left.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.right'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.up'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.up.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.up.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.up.square'
                                                                                                                                                                                                                                                                                                                        | 'arrow.uturn.up.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowkeys'
                                                                                                                                                                                                                                                                                                                        | 'arrowkeys.down.filled'
                                                                                                                                                                                                                                                                                                                        | 'arrowkeys.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowkeys.left.filled'
                                                                                                                                                                                                                                                                                                                        | 'arrowkeys.right.filled'
                                                                                                                                                                                                                                                                                                                        | 'arrowkeys.up.filled'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.backward'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.backward.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.bounce.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.bounce.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.bounce.right'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.bounce.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.down'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.down.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.down.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.left'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.left.arrowshape.right'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.left.arrowshape.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.right'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.2'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.2.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.badge.clock.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.badge.clock.rtl'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.backward.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.left'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.left.2'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.left.2.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.left.2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.left.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.right'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.turn.up.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.up'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.up.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.up.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.zigzag.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.zigzag.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.zigzag.right'
                                                                                                                                                                                                                                                                                                                        | 'arrowshape.zigzag.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.backward'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.backward.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.backward.inset.filled.leadingthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.backward.inset.filled.trailingthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.backward.leadingside.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.backward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.backward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.down.2'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.down.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.down.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.down.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.down.square'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.down.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.forward'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.forward.inset.filled.trailingthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.forward.square'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.forward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.forward.trailingside.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left.and.line.vertical.and.arrowtriangle.right'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left.and.line.vertical.and.arrowtriangle.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left.fill.and.line.vertical.and.arrowtriangle.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left.inset.filled.leftthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left.leftside.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left.square'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.left.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right.and.line.vertical.and.arrowtriangle.left'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right.and.line.vertical.and.arrowtriangle.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right.fill.and.line.vertical.and.arrowtriangle.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right.inset.filled.rightthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right.rightside.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right.square'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.up'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.up.2'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.up.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.up.arrowtriangle.down.window.left'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.up.arrowtriangle.down.window.right'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.up.circle'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.up.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.up.square'
                                                                                                                                                                                                                                                                                                                        | 'arrowtriangle.up.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'aspectratio'
                                                                                                                                                                                                                                                                                                                        | 'aspectratio.fill'
                                                                                                                                                                                                                                                                                                                        | 'asterisk'
                                                                                                                                                                                                                                                                                                                        | 'asterisk.circle'
                                                                                                                                                                                                                                                                                                                        | 'asterisk.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'at'
                                                                                                                                                                                                                                                                                                                        | 'at.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'at.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'at.circle'
                                                                                                                                                                                                                                                                                                                        | 'at.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'atom'
                                                                                                                                                                                                                                                                                                                        | 'audio.jack.mono'
                                                                                                                                                                                                                                                                                                                        | 'audio.jack.stereo'
                                                                                                                                                                                                                                                                                                                        | 'australian.football'
                                                                                                                                                                                                                                                                                                                        | 'australian.football.circle'
                                                                                                                                                                                                                                                                                                                        | 'australian.football.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'australian.football.fill'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.square'
                                                                                                                                                                                                                                                                                                                        | 'australiandollarsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'australsign'
                                                                                                                                                                                                                                                                                                                        | 'australsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'australsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'australsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'australsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'australsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'australsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'australsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'australsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'australsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'australsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'australsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'australsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'australsign.square'
                                                                                                                                                                                                                                                                                                                        | 'australsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'auto.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'auto.headlight.high.beam'
                                                                                                                                                                                                                                                                                                                        | 'auto.headlight.high.beam.fill'
                                                                                                                                                                                                                                                                                                                        | 'auto.headlight.low.beam'
                                                                                                                                                                                                                                                                                                                        | 'auto.headlight.low.beam.fill'
                                                                                                                                                                                                                                                                                                                        | 'automatic.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'automatic.headlight.high.beam'
                                                                                                                                                                                                                                                                                                                        | 'automatic.headlight.high.beam.fill'
                                                                                                                                                                                                                                                                                                                        | 'automatic.headlight.low.beam'
                                                                                                                                                                                                                                                                                                                        | 'automatic.headlight.low.beam.fill'
                                                                                                                                                                                                                                                                                                                        | 'autostartstop'
                                                                                                                                                                                                                                                                                                                        | 'autostartstop.slash'
                                                                                                                                                                                                                                                                                                                        | 'autostartstop.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'av.remote'
                                                                                                                                                                                                                                                                                                                        | 'av.remote.fill'
                                                                                                                                                                                                                                                                                                                        | 'axel.2'
                                                                                                                                                                                                                                                                                                                        | 'axel.2.front.and.rear.engaged'
                                                                                                                                                                                                                                                                                                                        | 'axel.2.front.engaged'
                                                                                                                                                                                                                                                                                                                        | 'axel.2.rear.engaged'
                                                                                                                                                                                                                                                                                                                        | 'axle.2'
                                                                                                                                                                                                                                                                                                                        | 'axle.2.driveshaft.disengaged'
                                                                                                                                                                                                                                                                                                                        | 'axle.2.front.and.rear.engaged'
                                                                                                                                                                                                                                                                                                                        | 'axle.2.front.disengaged'
                                                                                                                                                                                                                                                                                                                        | 'axle.2.front.engaged'
                                                                                                                                                                                                                                                                                                                        | 'axle.2.rear.disengaged'
                                                                                                                                                                                                                                                                                                                        | 'axle.2.rear.engaged'
                                                                                                                                                                                                                                                                                                                        | 'axle.2.rear.lock'
                                                                                                                                                                                                                                                                                                                        | 'b.circle'
                                                                                                                                                                                                                                                                                                                        | 'b.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'b.square'
                                                                                                                                                                                                                                                                                                                        | 'b.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'backpack'
                                                                                                                                                                                                                                                                                                                        | 'backpack.circle'
                                                                                                                                                                                                                                                                                                                        | 'backpack.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'backpack.fill'
                                                                                                                                                                                                                                                                                                                        | 'backpack.sensor.tag.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'backpack.sensor.tag.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'backward'
                                                                                                                                                                                                                                                                                                                        | 'backward.bubble'
                                                                                                                                                                                                                                                                                                                        | 'backward.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'backward.bubble.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'backward.bubble.rtl'
                                                                                                                                                                                                                                                                                                                        | 'backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'backward.end'
                                                                                                                                                                                                                                                                                                                        | 'backward.end.alt'
                                                                                                                                                                                                                                                                                                                        | 'backward.end.alt.fill'
                                                                                                                                                                                                                                                                                                                        | 'backward.end.circle'
                                                                                                                                                                                                                                                                                                                        | 'backward.end.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'backward.end.fill'
                                                                                                                                                                                                                                                                                                                        | 'backward.fill'
                                                                                                                                                                                                                                                                                                                        | 'backward.frame'
                                                                                                                                                                                                                                                                                                                        | 'backward.frame.fill'
                                                                                                                                                                                                                                                                                                                        | 'badge.plus.radiowaves.forward'
                                                                                                                                                                                                                                                                                                                        | 'badge.plus.radiowaves.right'
                                                                                                                                                                                                                                                                                                                        | 'bag'
                                                                                                                                                                                                                                                                                                                        | 'bag.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'bag.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'bag.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'bag.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'bag.circle'
                                                                                                                                                                                                                                                                                                                        | 'bag.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bag.fill'
                                                                                                                                                                                                                                                                                                                        | 'bag.fill.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'bag.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'bag.fill.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'bag.fill.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.square'
                                                                                                                                                                                                                                                                                                                        | 'bahtsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'balloon'
                                                                                                                                                                                                                                                                                                                        | 'balloon.2'
                                                                                                                                                                                                                                                                                                                        | 'balloon.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'balloon.fill'
                                                                                                                                                                                                                                                                                                                        | 'bandage'
                                                                                                                                                                                                                                                                                                                        | 'bandage.fill'
                                                                                                                                                                                                                                                                                                                        | 'banknote'
                                                                                                                                                                                                                                                                                                                        | 'banknote.fill'
                                                                                                                                                                                                                                                                                                                        | 'barcode'
                                                                                                                                                                                                                                                                                                                        | 'barcode.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'barometer'
                                                                                                                                                                                                                                                                                                                        | 'base.unit'
                                                                                                                                                                                                                                                                                                                        | 'baseball'
                                                                                                                                                                                                                                                                                                                        | 'baseball.circle'
                                                                                                                                                                                                                                                                                                                        | 'baseball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'baseball.diamond.bases'
                                                                                                                                                                                                                                                                                                                        | 'baseball.diamond.bases.outs.indicator'
                                                                                                                                                                                                                                                                                                                        | 'baseball.fill'
                                                                                                                                                                                                                                                                                                                        | 'basket'
                                                                                                                                                                                                                                                                                                                        | 'basket.fill'
                                                                                                                                                                                                                                                                                                                        | 'basketball'
                                                                                                                                                                                                                                                                                                                        | 'basketball.circle'
                                                                                                                                                                                                                                                                                                                        | 'basketball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'basketball.fill'
                                                                                                                                                                                                                                                                                                                        | 'bathtub'
                                                                                                                                                                                                                                                                                                                        | 'bathtub.fill'
                                                                                                                                                                                                                                                                                                                        | 'battery.0'
                                                                                                                                                                                                                                                                                                                        | 'battery.0percent'
                                                                                                                                                                                                                                                                                                                        | 'battery.100'
                                                                                                                                                                                                                                                                                                                        | 'battery.100.bolt'
                                                                                                                                                                                                                                                                                                                        | 'battery.100.bolt.rtl'
                                                                                                                                                                                                                                                                                                                        | 'battery.100.circle'
                                                                                                                                                                                                                                                                                                                        | 'battery.100.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'battery.100percent'
                                                                                                                                                                                                                                                                                                                        | 'battery.100percent.bolt'
                                                                                                                                                                                                                                                                                                                        | 'battery.100percent.bolt.rtl'
                                                                                                                                                                                                                                                                                                                        | 'battery.100percent.circle'
                                                                                                                                                                                                                                                                                                                        | 'battery.100percent.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'battery.25'
                                                                                                                                                                                                                                                                                                                        | 'battery.25percent'
                                                                                                                                                                                                                                                                                                                        | 'battery.50'
                                                                                                                                                                                                                                                                                                                        | 'battery.50percent'
                                                                                                                                                                                                                                                                                                                        | 'battery.75'
                                                                                                                                                                                                                                                                                                                        | 'battery.75percent'
                                                                                                                                                                                                                                                                                                                        | 'batteryblock'
                                                                                                                                                                                                                                                                                                                        | 'batteryblock.fill'
                                                                                                                                                                                                                                                                                                                        | 'batteryblock.slash'
                                                                                                                                                                                                                                                                                                                        | 'batteryblock.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'batteryblock.stack'
                                                                                                                                                                                                                                                                                                                        | 'batteryblock.stack.badge.snowflake'
                                                                                                                                                                                                                                                                                                                        | 'batteryblock.stack.badge.snowflake.fill'
                                                                                                                                                                                                                                                                                                                        | 'batteryblock.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'batteryblock.stack.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'batteryblock.stack.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'beach.umbrella'
                                                                                                                                                                                                                                                                                                                        | 'beach.umbrella.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.earphones'
                                                                                                                                                                                                                                                                                                                        | 'beats.fit.pro'
                                                                                                                                                                                                                                                                                                                        | 'beats.fit.pro.chargingcase'
                                                                                                                                                                                                                                                                                                                        | 'beats.fit.pro.chargingcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.fit.pro.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.fit.pro.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.fitpro'
                                                                                                                                                                                                                                                                                                                        | 'beats.fitpro.chargingcase'
                                                                                                                                                                                                                                                                                                                        | 'beats.fitpro.chargingcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.fitpro.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.fitpro.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.headphones'
                                                                                                                                                                                                                                                                                                                        | 'beats.pill'
                                                                                                                                                                                                                                                                                                                        | 'beats.pill.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.pro'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.pro.2'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.pro.2.chargingcase'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.pro.2.chargingcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.pro.2.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.pro.2.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.pro.chargingcase'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.pro.chargingcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.pro.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.pro.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats3'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats3.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeats3.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeatspro'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeatspro.chargingcase'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeatspro.chargingcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeatspro.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.powerbeatspro.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.solobuds'
                                                                                                                                                                                                                                                                                                                        | 'beats.solobuds.chargingcase'
                                                                                                                                                                                                                                                                                                                        | 'beats.solobuds.chargingcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.solobuds.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.solobuds.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobud.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobud.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobuds'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobuds.chargingcase'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobuds.chargingcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobuds.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobuds.plus'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobuds.plus.chargingcase'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobuds.plus.chargingcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobuds.plus.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobuds.plus.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobuds.right'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobudsplus'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobudsplus.chargingcase'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobudsplus.chargingcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobudsplus.left'
                                                                                                                                                                                                                                                                                                                        | 'beats.studiobudsplus.right'
                                                                                                                                                                                                                                                                                                                        | 'bed.double'
                                                                                                                                                                                                                                                                                                                        | 'bed.double.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'bed.double.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'bed.double.circle'
                                                                                                                                                                                                                                                                                                                        | 'bed.double.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bed.double.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell'
                                                                                                                                                                                                                                                                                                                        | 'bell.and.waveform'
                                                                                                                                                                                                                                                                                                                        | 'bell.and.waveform.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.and.waves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'bell.and.waves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.circle'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.slash'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.slash.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.slash.rtl'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.waveform'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.waveform.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.waveform.slash'
                                                                                                                                                                                                                                                                                                                        | 'bell.badge.waveform.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.circle'
                                                                                                                                                                                                                                                                                                                        | 'bell.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.slash'
                                                                                                                                                                                                                                                                                                                        | 'bell.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'bell.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'bell.square'
                                                                                                                                                                                                                                                                                                                        | 'bell.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'beziercurve'
                                                                                                                                                                                                                                                                                                                        | 'bicycle'
                                                                                                                                                                                                                                                                                                                        | 'bicycle.circle'
                                                                                                                                                                                                                                                                                                                        | 'bicycle.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bicycle.sensor.tag.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'bicycle.sensor.tag.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'bin.xmark'
                                                                                                                                                                                                                                                                                                                        | 'bin.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'binoculars'
                                                                                                                                                                                                                                                                                                                        | 'binoculars.circle'
                                                                                                                                                                                                                                                                                                                        | 'binoculars.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'binoculars.fill'
                                                                                                                                                                                                                                                                                                                        | 'bird'
                                                                                                                                                                                                                                                                                                                        | 'bird.circle'
                                                                                                                                                                                                                                                                                                                        | 'bird.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bird.fill'
                                                                                                                                                                                                                                                                                                                        | 'birthday.cake'
                                                                                                                                                                                                                                                                                                                        | 'birthday.cake.fill'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.square'
                                                                                                                                                                                                                                                                                                                        | 'bitcoinsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'blinds.horizontal.closed'
                                                                                                                                                                                                                                                                                                                        | 'blinds.horizontal.open'
                                                                                                                                                                                                                                                                                                                        | 'blinds.vertical.closed'
                                                                                                                                                                                                                                                                                                                        | 'blinds.vertical.open'
                                                                                                                                                                                                                                                                                                                        | 'blood.pressure.cuff'
                                                                                                                                                                                                                                                                                                                        | 'blood.pressure.cuff.badge.gauge.with.needle'
                                                                                                                                                                                                                                                                                                                        | 'blood.pressure.cuff.badge.gauge.with.needle.fill'
                                                                                                                                                                                                                                                                                                                        | 'blood.pressure.cuff.fill'
                                                                                                                                                                                                                                                                                                                        | 'bold'
                                                                                                                                                                                                                                                                                                                        | 'bold.italic.underline'
                                                                                                                                                                                                                                                                                                                        | 'bold.underline'
                                                                                                                                                                                                                                                                                                                        | 'bolt'
                                                                                                                                                                                                                                                                                                                        | 'bolt.badge.a'
                                                                                                                                                                                                                                                                                                                        | 'bolt.badge.a.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.badge.automatic'
                                                                                                                                                                                                                                                                                                                        | 'bolt.badge.automatic.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'bolt.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'bolt.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'bolt.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.batteryblock'
                                                                                                                                                                                                                                                                                                                        | 'bolt.batteryblock.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'bolt.car'
                                                                                                                                                                                                                                                                                                                        | 'bolt.car.circle'
                                                                                                                                                                                                                                                                                                                        | 'bolt.car.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.car.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.circle'
                                                                                                                                                                                                                                                                                                                        | 'bolt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.fill.batteryblock'
                                                                                                                                                                                                                                                                                                                        | 'bolt.fill.batteryblock.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.heart'
                                                                                                                                                                                                                                                                                                                        | 'bolt.heart.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'bolt.horizontal.circle'
                                                                                                                                                                                                                                                                                                                        | 'bolt.horizontal.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.horizontal.icloud'
                                                                                                                                                                                                                                                                                                                        | 'bolt.horizontal.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.house'
                                                                                                                                                                                                                                                                                                                        | 'bolt.house.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.ring.closed'
                                                                                                                                                                                                                                                                                                                        | 'bolt.shield'
                                                                                                                                                                                                                                                                                                                        | 'bolt.shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.slash'
                                                                                                                                                                                                                                                                                                                        | 'bolt.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'bolt.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.square'
                                                                                                                                                                                                                                                                                                                        | 'bolt.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'bolt.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'bolt.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'bonjour'
                                                                                                                                                                                                                                                                                                                        | 'book'
                                                                                                                                                                                                                                                                                                                        | 'book.and.wrench'
                                                                                                                                                                                                                                                                                                                        | 'book.and.wrench.fill'
                                                                                                                                                                                                                                                                                                                        | 'book.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'book.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'book.circle'
                                                                                                                                                                                                                                                                                                                        | 'book.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'book.closed'
                                                                                                                                                                                                                                                                                                                        | 'book.closed.circle'
                                                                                                                                                                                                                                                                                                                        | 'book.closed.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'book.closed.fill'
                                                                                                                                                                                                                                                                                                                        | 'book.fill'
                                                                                                                                                                                                                                                                                                                        | 'book.pages'
                                                                                                                                                                                                                                                                                                                        | 'book.pages.fill'
                                                                                                                                                                                                                                                                                                                        | 'bookmark'
                                                                                                                                                                                                                                                                                                                        | 'bookmark.circle'
                                                                                                                                                                                                                                                                                                                        | 'bookmark.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bookmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'bookmark.slash'
                                                                                                                                                                                                                                                                                                                        | 'bookmark.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'bookmark.square'
                                                                                                                                                                                                                                                                                                                        | 'bookmark.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'books.vertical'
                                                                                                                                                                                                                                                                                                                        | 'books.vertical.circle'
                                                                                                                                                                                                                                                                                                                        | 'books.vertical.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'books.vertical.fill'
                                                                                                                                                                                                                                                                                                                        | 'box.truck'
                                                                                                                                                                                                                                                                                                                        | 'box.truck.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'box.truck.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'box.truck.badge.clock.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'box.truck.badge.clock.rtl'
                                                                                                                                                                                                                                                                                                                        | 'box.truck.fill'
                                                                                                                                                                                                                                                                                                                        | 'brain'
                                                                                                                                                                                                                                                                                                                        | 'brain.fill'
                                                                                                                                                                                                                                                                                                                        | 'brain.filled.head.profile'
                                                                                                                                                                                                                                                                                                                        | 'brain.head.profile'
                                                                                                                                                                                                                                                                                                                        | 'brain.head.profile.fill'
                                                                                                                                                                                                                                                                                                                        | 'brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'brakesignal.dashed'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.square'
                                                                                                                                                                                                                                                                                                                        | 'brazilianrealsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'briefcase'
                                                                                                                                                                                                                                                                                                                        | 'briefcase.circle'
                                                                                                                                                                                                                                                                                                                        | 'briefcase.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'briefcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'briefcase.sensor.tag.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'briefcase.sensor.tag.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble'
                                                                                                                                                                                                                                                                                                                        | 'bubble.and.pencil'
                                                                                                                                                                                                                                                                                                                        | 'bubble.and.pencil.rtl'
                                                                                                                                                                                                                                                                                                                        | 'bubble.circle'
                                                                                                                                                                                                                                                                                                                        | 'bubble.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.and.bubble.right'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.and.bubble.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.and.exclamationmark.bubble.right'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.and.exclamationmark.bubble.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.and.heart.bubble.right'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.and.heart.bubble.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.and.text.bubble.right'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.and.text.bubble.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.and.text.bubble.right.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.and.text.bubble.right.rtl'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.middle.bottom'
                                                                                                                                                                                                                                                                                                                        | 'bubble.middle.bottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.middle.top'
                                                                                                                                                                                                                                                                                                                        | 'bubble.middle.top.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.right'
                                                                                                                                                                                                                                                                                                                        | 'bubble.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'bubble.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubble.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'bubbles.and.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'bubbles.and.sparkles.fill'
                                                                                                                                                                                                                                                                                                                        | 'building'
                                                                                                                                                                                                                                                                                                                        | 'building.2'
                                                                                                                                                                                                                                                                                                                        | 'building.2.crop.circle'
                                                                                                                                                                                                                                                                                                                        | 'building.2.crop.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'building.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'building.classical.columns'
                                                                                                                                                                                                                                                                                                                        | 'building.classical.columns.circle'
                                                                                                                                                                                                                                                                                                                        | 'building.classical.columns.fill'
                                                                                                                                                                                                                                                                                                                        | 'building.columns'
                                                                                                                                                                                                                                                                                                                        | 'building.columns.circle'
                                                                                                                                                                                                                                                                                                                        | 'building.columns.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'building.columns.fill'
                                                                                                                                                                                                                                                                                                                        | 'building.fill'
                                                                                                                                                                                                                                                                                                                        | 'burn'
                                                                                                                                                                                                                                                                                                                        | 'burst'
                                                                                                                                                                                                                                                                                                                        | 'burst.fill'
                                                                                                                                                                                                                                                                                                                        | 'bus'
                                                                                                                                                                                                                                                                                                                        | 'bus.doubledecker'
                                                                                                                                                                                                                                                                                                                        | 'bus.doubledecker.fill'
                                                                                                                                                                                                                                                                                                                        | 'bus.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.angledbottom.horizontal.left'
                                                                                                                                                                                                                                                                                                                        | 'button.angledbottom.horizontal.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.angledbottom.horizontal.right'
                                                                                                                                                                                                                                                                                                                        | 'button.angledbottom.horizontal.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.angledtop.vertical.left'
                                                                                                                                                                                                                                                                                                                        | 'button.angledtop.vertical.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.angledtop.vertical.right'
                                                                                                                                                                                                                                                                                                                        | 'button.angledtop.vertical.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.horizontal.top'
                                                                                                                                                                                                                                                                                                                        | 'button.horizontal.top.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.horizontal.top.press'
                                                                                                                                                                                                                                                                                                                        | 'button.horizontal.top.press.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.programmable'
                                                                                                                                                                                                                                                                                                                        | 'button.programmable.square'
                                                                                                                                                                                                                                                                                                                        | 'button.programmable.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.roundedbottom.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'button.roundedbottom.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.roundedtop.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'button.roundedtop.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.vertical.left'
                                                                                                                                                                                                                                                                                                                        | 'button.vertical.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.vertical.left.press'
                                                                                                                                                                                                                                                                                                                        | 'button.vertical.left.press.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.vertical.right'
                                                                                                                                                                                                                                                                                                                        | 'button.vertical.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'button.vertical.right.press'
                                                                                                                                                                                                                                                                                                                        | 'button.vertical.right.press.fill'
                                                                                                                                                                                                                                                                                                                        | 'c.circle'
                                                                                                                                                                                                                                                                                                                        | 'c.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'c.square'
                                                                                                                                                                                                                                                                                                                        | 'c.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'cabinet'
                                                                                                                                                                                                                                                                                                                        | 'cabinet.fill'
                                                                                                                                                                                                                                                                                                                        | 'cable.coaxial'
                                                                                                                                                                                                                                                                                                                        | 'cable.connector'
                                                                                                                                                                                                                                                                                                                        | 'cable.connector.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'cable.connector.slash'
                                                                                                                                                                                                                                                                                                                        | 'cable.connector.video'
                                                                                                                                                                                                                                                                                                                        | 'cablecar'
                                                                                                                                                                                                                                                                                                                        | 'cablecar.fill'
                                                                                                                                                                                                                                                                                                                        | 'calendar'
                                                                                                                                                                                                                                                                                                                        | 'calendar.and.person'
                                                                                                                                                                                                                                                                                                                        | 'calendar.badge'
                                                                                                                                                                                                                                                                                                                        | 'calendar.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'calendar.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'calendar.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'calendar.badge.clock.rtl'
                                                                                                                                                                                                                                                                                                                        | 'calendar.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'calendar.badge.lock'
                                                                                                                                                                                                                                                                                                                        | 'calendar.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'calendar.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'calendar.circle'
                                                                                                                                                                                                                                                                                                                        | 'calendar.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.leading'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.leading.circle'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.leading.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.left'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.right'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.trailing'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.trailing.circle'
                                                                                                                                                                                                                                                                                                                        | 'calendar.day.timeline.trailing.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera'
                                                                                                                                                                                                                                                                                                                        | 'camera.aperture'
                                                                                                                                                                                                                                                                                                                        | 'camera.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'camera.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'camera.badge.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera.circle'
                                                                                                                                                                                                                                                                                                                        | 'camera.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera.fill.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'camera.filters'
                                                                                                                                                                                                                                                                                                                        | 'camera.macro'
                                                                                                                                                                                                                                                                                                                        | 'camera.macro.circle'
                                                                                                                                                                                                                                                                                                                        | 'camera.macro.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera.macro.slash'
                                                                                                                                                                                                                                                                                                                        | 'camera.macro.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'camera.macro.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera.metering.center.weighted'
                                                                                                                                                                                                                                                                                                                        | 'camera.metering.center.weighted.average'
                                                                                                                                                                                                                                                                                                                        | 'camera.metering.matrix'
                                                                                                                                                                                                                                                                                                                        | 'camera.metering.multispot'
                                                                                                                                                                                                                                                                                                                        | 'camera.metering.none'
                                                                                                                                                                                                                                                                                                                        | 'camera.metering.partial'
                                                                                                                                                                                                                                                                                                                        | 'camera.metering.spot'
                                                                                                                                                                                                                                                                                                                        | 'camera.metering.unknown'
                                                                                                                                                                                                                                                                                                                        | 'camera.metering.unknown.ar'
                                                                                                                                                                                                                                                                                                                        | 'camera.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'camera.on.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera.rotate'
                                                                                                                                                                                                                                                                                                                        | 'camera.rotate.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera.sensor.tag.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'camera.sensor.tag.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera.shutter.button'
                                                                                                                                                                                                                                                                                                                        | 'camera.shutter.button.fill'
                                                                                                                                                                                                                                                                                                                        | 'camera.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'camera.viewfinder.badge.automatic'
                                                                                                                                                                                                                                                                                                                        | 'candybarphone'
                                                                                                                                                                                                                                                                                                                        | 'capslock'
                                                                                                                                                                                                                                                                                                                        | 'capslock.fill'
                                                                                                                                                                                                                                                                                                                        | 'capsule'
                                                                                                                                                                                                                                                                                                                        | 'capsule.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'capsule.fill'
                                                                                                                                                                                                                                                                                                                        | 'capsule.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'capsule.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'capsule.on.capsule'
                                                                                                                                                                                                                                                                                                                        | 'capsule.on.capsule.fill'
                                                                                                                                                                                                                                                                                                                        | 'capsule.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'capsule.on.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'capsule.on.rectangle.liquid.glass'
                                                                                                                                                                                                                                                                                                                        | 'capsule.on.rectangle.liquid.glass.fill'
                                                                                                                                                                                                                                                                                                                        | 'capsule.portrait'
                                                                                                                                                                                                                                                                                                                        | 'capsule.portrait.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'capsule.portrait.fill'
                                                                                                                                                                                                                                                                                                                        | 'capsule.portrait.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'capsule.portrait.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'capsule.portrait.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'capsule.portrait.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'capsule.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'capsule.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'captions.bubble'
                                                                                                                                                                                                                                                                                                                        | 'captions.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'car'
                                                                                                                                                                                                                                                                                                                        | 'car.2'
                                                                                                                                                                                                                                                                                                                        | 'car.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.badge.gearshape'
                                                                                                                                                                                                                                                                                                                        | 'car.badge.gearshape.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.card'
                                                                                                                                                                                                                                                                                                                        | 'car.card.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.circle'
                                                                                                                                                                                                                                                                                                                        | 'car.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.ferry'
                                                                                                                                                                                                                                                                                                                        | 'car.ferry.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.front.waves.down'
                                                                                                                                                                                                                                                                                                                        | 'car.front.waves.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.front.waves.left.and.right.and.up'
                                                                                                                                                                                                                                                                                                                        | 'car.front.waves.left.and.right.and.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.front.waves.up'
                                                                                                                                                                                                                                                                                                                        | 'car.front.waves.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.rear'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.and.collision.road.lane'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.and.collision.road.lane.slash'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.and.tire.marks'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.and.tire.marks.off'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.and.tire.marks.slash'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.hazardsign'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.hazardsign.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.dashed'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.dashed.arrowtriangle.2.outward'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.distance.1'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.distance.1.and.gauge.open.with.lines.needle.67percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.distance.2'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.distance.2.and.gauge.open.with.lines.needle.67percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.distance.3'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.distance.3.and.gauge.open.with.lines.needle.67percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.distance.4'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.distance.4.and.gauge.open.with.lines.needle.67percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.distance.5'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.distance.5.and.gauge.open.with.lines.needle.67percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.off'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.road.lane.wave.up'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.tilt.road.lanes.curved.right'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.waves.up'
                                                                                                                                                                                                                                                                                                                        | 'car.rear.waves.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side'
                                                                                                                                                                                                                                                                                                                        | 'car.side.air.circulate'
                                                                                                                                                                                                                                                                                                                        | 'car.side.air.circulate.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.air.fresh'
                                                                                                                                                                                                                                                                                                                        | 'car.side.air.fresh.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.and.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'car.side.and.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.arrow.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'car.side.arrow.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.arrowtriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'car.side.arrowtriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.arrowtriangle.up'
                                                                                                                                                                                                                                                                                                                        | 'car.side.arrowtriangle.up.arrowtriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'car.side.arrowtriangle.up.arrowtriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.arrowtriangle.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.front.open'
                                                                                                                                                                                                                                                                                                                        | 'car.side.front.open.crop'
                                                                                                                                                                                                                                                                                                                        | 'car.side.front.open.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.front.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.hill.descent.control'
                                                                                                                                                                                                                                                                                                                        | 'car.side.hill.descent.control.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.hill.down'
                                                                                                                                                                                                                                                                                                                        | 'car.side.hill.down.and.gauge.open.with.lines.needle.25percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'car.side.hill.down.and.gauge.open.with.lines.needle.25percent.and.arrowtriangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.hill.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.hill.up'
                                                                                                                                                                                                                                                                                                                        | 'car.side.hill.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.lock'
                                                                                                                                                                                                                                                                                                                        | 'car.side.lock.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.lock.open'
                                                                                                                                                                                                                                                                                                                        | 'car.side.lock.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.and.collision.and.car.side.front'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.and.collision.and.car.side.front.and.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.and.collision.and.car.side.front.and.steeringwheel'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.and.collision.and.car.side.front.slash'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.and.exclamationmark.and.car.side.front'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.and.exclamationmark.and.car.side.front.off'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.and.wave.3.and.car.side.front'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.crop.trunk.partition'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.crop.trunk.partition.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.open'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.open.crop'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.open.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.tow.hitch'
                                                                                                                                                                                                                                                                                                                        | 'car.side.rear.tow.hitch.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.roof.cargo.carrier'
                                                                                                                                                                                                                                                                                                                        | 'car.side.roof.cargo.carrier.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.side.roof.cargo.carrier.slash'
                                                                                                                                                                                                                                                                                                                        | 'car.side.roof.cargo.carrier.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.arrowtriangle.front.left'
                                                                                                                                                                                                                                                                                                                        | 'car.top.arrowtriangle.front.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.arrowtriangle.front.right'
                                                                                                                                                                                                                                                                                                                        | 'car.top.arrowtriangle.front.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.arrowtriangle.rear.left'
                                                                                                                                                                                                                                                                                                                        | 'car.top.arrowtriangle.rear.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.arrowtriangle.rear.right'
                                                                                                                                                                                                                                                                                                                        | 'car.top.arrowtriangle.rear.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.front.right.and.rear.left.and.rear.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.front.right.and.rear.left.and.rear.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.front.right.and.rear.left.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.front.right.and.rear.left.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.front.right.and.rear.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.front.right.and.rear.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.front.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.front.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.rear.left.and.rear.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.rear.left.and.rear.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.rear.left.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.rear.left.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.rear.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.and.rear.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.left.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.right.and.rear.left.and.rear.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.right.and.rear.left.and.rear.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.right.and.rear.left.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.right.and.rear.left.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.right.and.rear.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.right.and.rear.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.front.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.rear.left.and.rear.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.rear.left.and.rear.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.rear.left.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.rear.left.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.rear.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.rear.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.sliding.left.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.sliding.left.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.sliding.right.open'
                                                                                                                                                                                                                                                                                                                        | 'car.top.door.sliding.right.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.front.radiowaves.front.left.and.front.and.front.right'
                                                                                                                                                                                                                                                                                                                        | 'car.top.front.radiowaves.front.left.and.front.and.front.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.frontleft.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'car.top.frontleft.arrowtriangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.frontright.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'car.top.frontright.arrowtriangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.arrowtriangle.inward'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.arrowtriangle.inward.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.badge.steeringwheel'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.badge.steeringwheel.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.departure.left'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.departure.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.departure.left.slash'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.departure.left.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.departure.right'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.departure.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.departure.right.slash'
                                                                                                                                                                                                                                                                                                                        | 'car.top.lane.dashed.departure.right.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.2.front.left.front.front.right'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.2.front.left.front.front.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.2.rear.left.rear.rear.right'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.2.rear.left.rear.rear.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.front'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.front.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.left'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.left.and.rear.right'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.left.and.rear.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.left.car.top.front'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.left.car.top.front.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.right'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.right.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.right.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.right.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.right.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.right.car.top.front'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.right.car.top.front.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.radiowaves.rear.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.rear.radiowaves.rear.left.and.rear.and.rear.right'
                                                                                                                                                                                                                                                                                                                        | 'car.top.rear.radiowaves.rear.left.and.rear.and.rear.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.rearleft.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'car.top.rearleft.arrowtriangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.rearright.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'car.top.rearright.arrowtriangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.video.rear.left'
                                                                                                                                                                                                                                                                                                                        | 'car.top.video.rear.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.top.video.rear.right'
                                                                                                                                                                                                                                                                                                                        | 'car.top.video.rear.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'car.window.left'
                                                                                                                                                                                                                                                                                                                        | 'car.window.left.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'car.window.left.badge.lock'
                                                                                                                                                                                                                                                                                                                        | 'car.window.left.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'car.window.left.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'car.window.left.xmark'
                                                                                                                                                                                                                                                                                                                        | 'car.window.right'
                                                                                                                                                                                                                                                                                                                        | 'car.window.right.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'car.window.right.badge.lock'
                                                                                                                                                                                                                                                                                                                        | 'car.window.right.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'car.window.right.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'car.window.right.xmark'
                                                                                                                                                                                                                                                                                                                        | 'carbon.dioxide.cloud'
                                                                                                                                                                                                                                                                                                                        | 'carbon.dioxide.cloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'carbon.monoxide.cloud'
                                                                                                                                                                                                                                                                                                                        | 'carbon.monoxide.cloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'carrot'
                                                                                                                                                                                                                                                                                                                        | 'carrot.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.1'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.1.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.2'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.3'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.and.heat.waves.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.backrest.up.and.down'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.backrest.up.and.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.fan'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.fan.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.forward.and.backward'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.forward.and.backward.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.massage'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.massage.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.up.and.down'
                                                                                                                                                                                                                                                                                                                        | 'carseat.left.up.and.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.1'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.1.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.2'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.3'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.and.heat.waves.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.backrest.up.and.down'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.backrest.up.and.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.fan'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.fan.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.forward.and.backward'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.forward.and.backward.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.massage'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.massage.fill'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.up.and.down'
                                                                                                                                                                                                                                                                                                                        | 'carseat.right.up.and.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'cart'
                                                                                                                                                                                                                                                                                                                        | 'cart.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'cart.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'cart.badge.clock.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'cart.badge.clock.rtl'
                                                                                                                                                                                                                                                                                                                        | 'cart.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'cart.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'cart.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'cart.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'cart.badge.questionmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'cart.circle'
                                                                                                                                                                                                                                                                                                                        | 'cart.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cart.fill'
                                                                                                                                                                                                                                                                                                                        | 'cart.fill.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'cart.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'cart.fill.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'cart.fill.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'cart.fill.badge.questionmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'case'
                                                                                                                                                                                                                                                                                                                        | 'case.fill'
                                                                                                                                                                                                                                                                                                                        | 'cat'
                                                                                                                                                                                                                                                                                                                        | 'cat.circle'
                                                                                                                                                                                                                                                                                                                        | 'cat.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cat.fill'
                                                                                                                                                                                                                                                                                                                        | 'cedisign'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.circle'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.ring'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.square'
                                                                                                                                                                                                                                                                                                                        | 'cedisign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'cellularbars'
                                                                                                                                                                                                                                                                                                                        | 'cellularbars.circle'
                                                                                                                                                                                                                                                                                                                        | 'cellularbars.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cellularbars.short.cellularbars'
                                                                                                                                                                                                                                                                                                                        | 'centsign'
                                                                                                                                                                                                                                                                                                                        | 'centsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'centsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'centsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'centsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'centsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'centsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'centsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'centsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'centsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'centsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'centsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'centsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'centsign.square'
                                                                                                                                                                                                                                                                                                                        | 'centsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'chair'
                                                                                                                                                                                                                                                                                                                        | 'chair.fill'
                                                                                                                                                                                                                                                                                                                        | 'chair.lounge'
                                                                                                                                                                                                                                                                                                                        | 'chair.lounge.fill'
                                                                                                                                                                                                                                                                                                                        | 'chandelier'
                                                                                                                                                                                                                                                                                                                        | 'chandelier.fill'
                                                                                                                                                                                                                                                                                                                        | 'character'
                                                                                                                                                                                                                                                                                                                        | 'character.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.he'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.or'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.si'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.te'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.th'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.fill.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.he'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.or'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.si'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.te'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.th'
                                                                                                                                                                                                                                                                                                                        | 'character.book.closed.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.he'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.or'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.si'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.te'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.th'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.fill.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.he'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.or'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.si'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.te'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.th'
                                                                                                                                                                                                                                                                                                                        | 'character.bubble.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.circle'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.he'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.or'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.si'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.te'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.th'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.fill.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.he'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.or'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.si'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.te'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.th'
                                                                                                                                                                                                                                                                                                                        | 'character.circle.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.he'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.or'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.si'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.te'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.th'
                                                                                                                                                                                                                                                                                                                        | 'character.cursor.ibeam.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.duployan'
                                                                                                                                                                                                                                                                                                                        | 'character.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.he'
                                                                                                                                                                                                                                                                                                                        | 'character.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.he'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.or'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.si'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.te'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.th'
                                                                                                                                                                                                                                                                                                                        | 'character.magnify.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.or'
                                                                                                                                                                                                                                                                                                                        | 'character.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.phonetic'
                                                                                                                                                                                                                                                                                                                        | 'character.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.si'
                                                                                                                                                                                                                                                                                                                        | 'character.square'
                                                                                                                                                                                                                                                                                                                        | 'character.square.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.square.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.he'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.or'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.si'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.te'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.th'
                                                                                                                                                                                                                                                                                                                        | 'character.square.fill.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.square.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.square.he'
                                                                                                                                                                                                                                                                                                                        | 'character.square.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.square.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.square.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.square.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.square.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.square.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.square.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.square.or'
                                                                                                                                                                                                                                                                                                                        | 'character.square.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.square.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.square.si'
                                                                                                                                                                                                                                                                                                                        | 'character.square.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.square.te'
                                                                                                                                                                                                                                                                                                                        | 'character.square.th'
                                                                                                                                                                                                                                                                                                                        | 'character.square.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.sutton'
                                                                                                                                                                                                                                                                                                                        | 'character.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.te'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.he'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.or'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.si'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.te'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.th'
                                                                                                                                                                                                                                                                                                                        | 'character.text.justify.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.ar'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.he'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.or'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.si'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.te'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.th'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.badge.sparkles.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.bn'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.gu'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.he'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.hi'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.ja'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.kn'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.ko'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.ml'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.mni'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.mr'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.or'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.pa'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.sat'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.si'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.ta'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.te'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.th'
                                                                                                                                                                                                                                                                                                                        | 'character.textbox.zh'
                                                                                                                                                                                                                                                                                                                        | 'character.th'
                                                                                                                                                                                                                                                                                                                        | 'character.zh'
                                                                                                                                                                                                                                                                                                                        | 'characters.lowercase'
                                                                                                                                                                                                                                                                                                                        | 'characters.lowercase.el'
                                                                                                                                                                                                                                                                                                                        | 'characters.lowercase.ru'
                                                                                                                                                                                                                                                                                                                        | 'characters.uppercase'
                                                                                                                                                                                                                                                                                                                        | 'characters.uppercase.el'
                                                                                                                                                                                                                                                                                                                        | 'characters.uppercase.ru'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.doc.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.doc.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.fill'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.horizontal.page'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.horizontal.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.xaxis'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.xaxis.ascending'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.xaxis.ascending.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.xaxis.ascending.badge.clock.rtl'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.xaxis.descending'
                                                                                                                                                                                                                                                                                                                        | 'chart.bar.yaxis'
                                                                                                                                                                                                                                                                                                                        | 'chart.dots.scatter'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.downtrend.xyaxis'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.downtrend.xyaxis.circle'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.downtrend.xyaxis.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.flattrend.xyaxis'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.flattrend.xyaxis.circle'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.flattrend.xyaxis.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.text.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.text.clipboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.uptrend.xyaxis'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.uptrend.xyaxis.circle'
                                                                                                                                                                                                                                                                                                                        | 'chart.line.uptrend.xyaxis.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'chart.pie'
                                                                                                                                                                                                                                                                                                                        | 'chart.pie.fill'
                                                                                                                                                                                                                                                                                                                        | 'chart.xyaxis.line'
                                                                                                                                                                                                                                                                                                                        | 'checkerboard.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'checkerboard.shield'
                                                                                                                                                                                                                                                                                                                        | 'checklist'
                                                                                                                                                                                                                                                                                                                        | 'checklist.checked'
                                                                                                                                                                                                                                                                                                                        | 'checklist.checked.rtl'
                                                                                                                                                                                                                                                                                                                        | 'checklist.rtl'
                                                                                                                                                                                                                                                                                                                        | 'checklist.unchecked'
                                                                                                                                                                                                                                                                                                                        | 'checkmark'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.app'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.applewatch'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.bubble'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.bubble.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.bubble.rtl'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.badge.airplane'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.badge.airplane.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.badge.questionmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.badge.questionmark.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.circle.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.diamond'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.gobackward'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.icloud'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.message'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.message.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.rectangle.portrait.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.rectangle.stack'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.rectangle.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.seal'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.seal.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.seal.text.page'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.seal.text.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.seal.text.page.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.seal.text.page.rtl'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.shield'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.square'
                                                                                                                                                                                                                                                                                                                        | 'checkmark.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.backward'
                                                                                                                                                                                                                                                                                                                        | 'chevron.backward.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.backward.chevron.backward.dotted'
                                                                                                                                                                                                                                                                                                                        | 'chevron.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'chevron.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.backward.square'
                                                                                                                                                                                                                                                                                                                        | 'chevron.backward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.backward.to.line'
                                                                                                                                                                                                                                                                                                                        | 'chevron.compact.backward'
                                                                                                                                                                                                                                                                                                                        | 'chevron.compact.down'
                                                                                                                                                                                                                                                                                                                        | 'chevron.compact.forward'
                                                                                                                                                                                                                                                                                                                        | 'chevron.compact.left'
                                                                                                                                                                                                                                                                                                                        | 'chevron.compact.left.chevron.compact.right'
                                                                                                                                                                                                                                                                                                                        | 'chevron.compact.right'
                                                                                                                                                                                                                                                                                                                        | 'chevron.compact.up'
                                                                                                                                                                                                                                                                                                                        | 'chevron.compact.up.chevron.compact.down'
                                                                                                                                                                                                                                                                                                                        | 'chevron.compact.up.chevron.compact.right.chevron.compact.down.chevron.compact.left'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down.circle'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down.dotted.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down.forward.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down.forward.dotted.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down.right.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down.right.dotted.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down.square'
                                                                                                                                                                                                                                                                                                                        | 'chevron.down.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.forward'
                                                                                                                                                                                                                                                                                                                        | 'chevron.forward.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'chevron.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.forward.dotted.chevron.forward'
                                                                                                                                                                                                                                                                                                                        | 'chevron.forward.square'
                                                                                                                                                                                                                                                                                                                        | 'chevron.forward.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.forward.to.line'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left.chevron.left.dotted'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left.chevron.right'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left.forwardslash.chevron.right'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left.slash.chevron.right'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left.square'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.left.to.line'
                                                                                                                                                                                                                                                                                                                        | 'chevron.right'
                                                                                                                                                                                                                                                                                                                        | 'chevron.right.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'chevron.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.right.dotted.chevron.right'
                                                                                                                                                                                                                                                                                                                        | 'chevron.right.square'
                                                                                                                                                                                                                                                                                                                        | 'chevron.right.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.right.to.line'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.chevron.down'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.chevron.down.square'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.chevron.down.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.chevron.right.chevron.down.chevron.left'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.circle'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.dotted.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.forward.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.forward.dotted.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.right.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.right.dotted.2'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.square'
                                                                                                                                                                                                                                                                                                                        | 'chevron.up.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.circle'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.ring'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.square'
                                                                                                                                                                                                                                                                                                                        | 'chineseyuanrenminbisign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle'
                                                                                                                                                                                                                                                                                                                        | 'circle.and.line.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'circle.and.line.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.questionmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.questionmark.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'circle.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.bottomhalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.bottomhalf.filled.inverse'
                                                                                                                                                                                                                                                                                                                        | 'circle.bottomrighthalf.checkered'
                                                                                                                                                                                                                                                                                                                        | 'circle.bottomrighthalf.pattern.checkered'
                                                                                                                                                                                                                                                                                                                        | 'circle.bottomthird.split'
                                                                                                                                                                                                                                                                                                                        | 'circle.circle'
                                                                                                                                                                                                                                                                                                                        | 'circle.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'circle.dashed.inset.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.dashed.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.dashed.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'circle.dotted.and.circle'
                                                                                                                                                                                                                                                                                                                        | 'circle.dotted.circle'
                                                                                                                                                                                                                                                                                                                        | 'circle.dotted.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.fill.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.filled.ipad'
                                                                                                                                                                                                                                                                                                                        | 'circle.filled.ipad.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.filled.ipad.landscape'
                                                                                                                                                                                                                                                                                                                        | 'circle.filled.ipad.landscape.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.filled.iphone'
                                                                                                                                                                                                                                                                                                                        | 'circle.filled.iphone.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.filled.pattern.diagonalline.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.2x1'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.2x1.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.2x1.left.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.2x1.right.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.2x2'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.2x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.2x2.topleft.checkmark.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.3x3'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.3x3.circle'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.3x3.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.3x3.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.cross'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.cross.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.cross.down.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.cross.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.cross.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.cross.left.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.cross.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.cross.right.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.cross.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.cross.up.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.hex'
                                                                                                                                                                                                                                                                                                                        | 'circle.grid.hex.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.hexagongrid'
                                                                                                                                                                                                                                                                                                                        | 'circle.hexagongrid.circle'
                                                                                                                                                                                                                                                                                                                        | 'circle.hexagongrid.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.hexagongrid.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.hexagonpath'
                                                                                                                                                                                                                                                                                                                        | 'circle.hexagonpath.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.lefthalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.lefthalf.filled.inverse'
                                                                                                                                                                                                                                                                                                                        | 'circle.lefthalf.filled.righthalf.striped.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'circle.lefthalf.filled.righthalf.striped.horizontal.inverse'
                                                                                                                                                                                                                                                                                                                        | 'circle.lefthalf.striped.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'circle.lefthalf.striped.horizontal.inverse'
                                                                                                                                                                                                                                                                                                                        | 'circle.on.app.liquid.glass'
                                                                                                                                                                                                                                                                                                                        | 'circle.on.app.liquid.glass.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.on.square'
                                                                                                                                                                                                                                                                                                                        | 'circle.on.square.intersection.dotted'
                                                                                                                                                                                                                                                                                                                        | 'circle.on.square.merge'
                                                                                                                                                                                                                                                                                                                        | 'circle.rectangle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'circle.rectangle.filled.pattern.diagonalline'
                                                                                                                                                                                                                                                                                                                        | 'circle.righthalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.righthalf.filled.inverse'
                                                                                                                                                                                                                                                                                                                        | 'circle.slash'
                                                                                                                                                                                                                                                                                                                        | 'circle.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.square'
                                                                                                                                                                                                                                                                                                                        | 'circle.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.tophalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'circle.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'circle.tophalf.filled.inverse'
                                                                                                                                                                                                                                                                                                                        | 'circlebadge'
                                                                                                                                                                                                                                                                                                                        | 'circlebadge.2'
                                                                                                                                                                                                                                                                                                                        | 'circlebadge.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'circlebadge.fill'
                                                                                                                                                                                                                                                                                                                        | 'circles.hexagongrid'
                                                                                                                                                                                                                                                                                                                        | 'circles.hexagongrid.fill'
                                                                                                                                                                                                                                                                                                                        | 'circles.hexagonpath'
                                                                                                                                                                                                                                                                                                                        | 'circles.hexagonpath.fill'
                                                                                                                                                                                                                                                                                                                        | 'clear'
                                                                                                                                                                                                                                                                                                                        | 'clear.fill'
                                                                                                                                                                                                                                                                                                                        | 'clipboard'
                                                                                                                                                                                                                                                                                                                        | 'clipboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'clock'
                                                                                                                                                                                                                                                                                                                        | 'clock.arrow.2.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'clock.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'clock.arrow.trianglehead.2.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'clock.arrow.trianglehead.clockwise.rotate.90.path.dotted'
                                                                                                                                                                                                                                                                                                                        | 'clock.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.airplane'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.airplane.fill'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.fill'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.questionmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.questionmark.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'clock.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'clock.circle'
                                                                                                                                                                                                                                                                                                                        | 'clock.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud'
                                                                                                                                                                                                                                                                                                                        | 'cloud.bolt'
                                                                                                                                                                                                                                                                                                                        | 'cloud.bolt.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.bolt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.bolt.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.bolt.rain'
                                                                                                                                                                                                                                                                                                                        | 'cloud.bolt.rain.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.bolt.rain.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.bolt.rain.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.drizzle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.drizzle.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.drizzle.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.drizzle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.fog'
                                                                                                                                                                                                                                                                                                                        | 'cloud.fog.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.fog.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.fog.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.hail'
                                                                                                                                                                                                                                                                                                                        | 'cloud.hail.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.hail.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.hail.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.heavyrain'
                                                                                                                                                                                                                                                                                                                        | 'cloud.heavyrain.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.heavyrain.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.heavyrain.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.bolt'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.bolt.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.bolt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.bolt.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.rain'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.rain.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.rain.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.moon.rain.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.rain'
                                                                                                                                                                                                                                                                                                                        | 'cloud.rain.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.rain.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.rain.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.rainbow.crop'
                                                                                                                                                                                                                                                                                                                        | 'cloud.rainbow.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.rainbow.half'
                                                                                                                                                                                                                                                                                                                        | 'cloud.rainbow.half.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sleet'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sleet.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sleet.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sleet.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.snow'
                                                                                                                                                                                                                                                                                                                        | 'cloud.snow.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.snow.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.snow.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.bolt'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.bolt.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.bolt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.bolt.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.rain'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.rain.circle'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.rain.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cloud.sun.rain.fill'
                                                                                                                                                                                                                                                                                                                        | 'coat'
                                                                                                                                                                                                                                                                                                                        | 'coat.circle'
                                                                                                                                                                                                                                                                                                                        | 'coat.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'coat.fill'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.circle'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.ring'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.square'
                                                                                                                                                                                                                                                                                                                        | 'coloncurrencysign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'comb'
                                                                                                                                                                                                                                                                                                                        | 'comb.fill'
                                                                                                                                                                                                                                                                                                                        | 'command'
                                                                                                                                                                                                                                                                                                                        | 'command.circle'
                                                                                                                                                                                                                                                                                                                        | 'command.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'command.square'
                                                                                                                                                                                                                                                                                                                        | 'command.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'compass.drawing'
                                                                                                                                                                                                                                                                                                                        | 'computermouse'
                                                                                                                                                                                                                                                                                                                        | 'computermouse.fill'
                                                                                                                                                                                                                                                                                                                        | 'cone'
                                                                                                                                                                                                                                                                                                                        | 'cone.fill'
                                                                                                                                                                                                                                                                                                                        | 'contact.sensor'
                                                                                                                                                                                                                                                                                                                        | 'contact.sensor.fill'
                                                                                                                                                                                                                                                                                                                        | 'contextualmenu.and.cursorarrow'
                                                                                                                                                                                                                                                                                                                        | 'contextualmenu.and.pointer.arrow'
                                                                                                                                                                                                                                                                                                                        | 'control'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.air.circulate'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.air.circulate.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.air.fresh'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.air.fresh.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.and.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.and.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrow.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrow.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrow.trianglehead.backward'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrow.trianglehead.backward.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrow.trianglehead.forward'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrow.trianglehead.forward.and.backward'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrow.trianglehead.forward.and.backward.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrow.trianglehead.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrowtriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrowtriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrowtriangle.up'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrowtriangle.up.arrowtriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrowtriangle.up.arrowtriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.arrowtriangle.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.front.open'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.front.open.crop'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.front.open.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.front.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.hill.descent.control'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.hill.descent.control.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.hill.down'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.hill.down.and.gauge.open.with.lines.needle.25percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.hill.down.and.gauge.open.with.lines.needle.25percent.and.arrowtriangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.hill.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.hill.up'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.hill.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.lock'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.lock.fill'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.lock.open'
                                                                                                                                                                                                                                                                                                                        | 'convertible.side.lock.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'cooktop'
                                                                                                                                                                                                                                                                                                                        | 'cooktop.fill'
                                                                                                                                                                                                                                                                                                                        | 'cpu'
                                                                                                                                                                                                                                                                                                                        | 'cpu.fill'
                                                                                                                                                                                                                                                                                                                        | 'creditcard'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.and.123'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.and.numbers'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.arrow.trianglehead.2.clockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.circle'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.fill'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.rewards'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.rewards.fill'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'creditcard.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'cricket.ball'
                                                                                                                                                                                                                                                                                                                        | 'cricket.ball.circle'
                                                                                                                                                                                                                                                                                                                        | 'cricket.ball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cricket.ball.fill'
                                                                                                                                                                                                                                                                                                                        | 'crop'
                                                                                                                                                                                                                                                                                                                        | 'crop.rotate'
                                                                                                                                                                                                                                                                                                                        | 'cross'
                                                                                                                                                                                                                                                                                                                        | 'cross.case'
                                                                                                                                                                                                                                                                                                                        | 'cross.case.circle'
                                                                                                                                                                                                                                                                                                                        | 'cross.case.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cross.case.fill'
                                                                                                                                                                                                                                                                                                                        | 'cross.circle'
                                                                                                                                                                                                                                                                                                                        | 'cross.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cross.fill'
                                                                                                                                                                                                                                                                                                                        | 'cross.vial'
                                                                                                                                                                                                                                                                                                                        | 'cross.vial.fill'
                                                                                                                                                                                                                                                                                                                        | 'crown'
                                                                                                                                                                                                                                                                                                                        | 'crown.fill'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.circle'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.ring'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.square'
                                                                                                                                                                                                                                                                                                                        | 'cruzeirosign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'cube'
                                                                                                                                                                                                                                                                                                                        | 'cube.badge.paintbrush'
                                                                                                                                                                                                                                                                                                                        | 'cube.badge.paintbrush.fill'
                                                                                                                                                                                                                                                                                                                        | 'cube.box'
                                                                                                                                                                                                                                                                                                                        | 'cube.box.fill'
                                                                                                                                                                                                                                                                                                                        | 'cube.circle'
                                                                                                                                                                                                                                                                                                                        | 'cube.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'cube.fill'
                                                                                                                                                                                                                                                                                                                        | 'cube.plane.bottom.right.detached'
                                                                                                                                                                                                                                                                                                                        | 'cube.plane.bottom.right.detached.fill'
                                                                                                                                                                                                                                                                                                                        | 'cube.transparent'
                                                                                                                                                                                                                                                                                                                        | 'cube.transparent.fill'
                                                                                                                                                                                                                                                                                                                        | 'cup.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'cup.and.heat.waves.fill'
                                                                                                                                                                                                                                                                                                                        | 'cup.and.saucer'
                                                                                                                                                                                                                                                                                                                        | 'cup.and.saucer.fill'
                                                                                                                                                                                                                                                                                                                        | 'curlybraces'
                                                                                                                                                                                                                                                                                                                        | 'curlybraces.square'
                                                                                                                                                                                                                                                                                                                        | 'curlybraces.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'cursor.rays'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.and.square.on.square.dashed'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.click'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.click.2'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.click.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.motionlines'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.motionlines.click'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.rays'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.resize.north.east.south.east'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.slash'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.slash.square'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.slash.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.square'
                                                                                                                                                                                                                                                                                                                        | 'cursorarrow.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'curtains.closed'
                                                                                                                                                                                                                                                                                                                        | 'curtains.open'
                                                                                                                                                                                                                                                                                                                        | 'cylinder'
                                                                                                                                                                                                                                                                                                                        | 'cylinder.fill'
                                                                                                                                                                                                                                                                                                                        | 'cylinder.split.1x2'
                                                                                                                                                                                                                                                                                                                        | 'cylinder.split.1x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'd.circle'
                                                                                                                                                                                                                                                                                                                        | 'd.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'd.square'
                                                                                                                                                                                                                                                                                                                        | 'd.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.circle'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.ring'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.square'
                                                                                                                                                                                                                                                                                                                        | 'danishkronesign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'decrease.indent'
                                                                                                                                                                                                                                                                                                                        | 'decrease.quotelevel'
                                                                                                                                                                                                                                                                                                                        | 'degreesign.celsius'
                                                                                                                                                                                                                                                                                                                        | 'degreesign.fahrenheit'
                                                                                                                                                                                                                                                                                                                        | 'dehumidifier'
                                                                                                                                                                                                                                                                                                                        | 'dehumidifier.fill'
                                                                                                                                                                                                                                                                                                                        | 'delete.backward'
                                                                                                                                                                                                                                                                                                                        | 'delete.backward.fill'
                                                                                                                                                                                                                                                                                                                        | 'delete.forward'
                                                                                                                                                                                                                                                                                                                        | 'delete.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'delete.left'
                                                                                                                                                                                                                                                                                                                        | 'delete.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'delete.right'
                                                                                                                                                                                                                                                                                                                        | 'delete.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'deskclock'
                                                                                                                                                                                                                                                                                                                        | 'deskclock.fill'
                                                                                                                                                                                                                                                                                                                        | 'desktopcomputer'
                                                                                                                                                                                                                                                                                                                        | 'desktopcomputer.and.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'desktopcomputer.and.macbook'
                                                                                                                                                                                                                                                                                                                        | 'desktopcomputer.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'desktopcomputer.badge.shield.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'desktopcomputer.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'deskview'
                                                                                                                                                                                                                                                                                                                        | 'deskview.fill'
                                                                                                                                                                                                                                                                                                                        | 'dial'
                                                                                                                                                                                                                                                                                                                        | 'dial.fill'
                                                                                                                                                                                                                                                                                                                        | 'dial.high'
                                                                                                                                                                                                                                                                                                                        | 'dial.high.fill'
                                                                                                                                                                                                                                                                                                                        | 'dial.low'
                                                                                                                                                                                                                                                                                                                        | 'dial.low.fill'
                                                                                                                                                                                                                                                                                                                        | 'dial.max'
                                                                                                                                                                                                                                                                                                                        | 'dial.max.fill'
                                                                                                                                                                                                                                                                                                                        | 'dial.medium'
                                                                                                                                                                                                                                                                                                                        | 'dial.medium.fill'
                                                                                                                                                                                                                                                                                                                        | 'dial.min'
                                                                                                                                                                                                                                                                                                                        | 'dial.min.fill'
                                                                                                                                                                                                                                                                                                                        | 'diamond'
                                                                                                                                                                                                                                                                                                                        | 'diamond.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'diamond.circle'
                                                                                                                                                                                                                                                                                                                        | 'diamond.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'diamond.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'diamond.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'diamond.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'diamond.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'dice'
                                                                                                                                                                                                                                                                                                                        | 'dice.fill'
                                                                                                                                                                                                                                                                                                                        | 'die.face.1'
                                                                                                                                                                                                                                                                                                                        | 'die.face.1.fill'
                                                                                                                                                                                                                                                                                                                        | 'die.face.2'
                                                                                                                                                                                                                                                                                                                        | 'die.face.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'die.face.3'
                                                                                                                                                                                                                                                                                                                        | 'die.face.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'die.face.4'
                                                                                                                                                                                                                                                                                                                        | 'die.face.4.fill'
                                                                                                                                                                                                                                                                                                                        | 'die.face.5'
                                                                                                                                                                                                                                                                                                                        | 'die.face.5.fill'
                                                                                                                                                                                                                                                                                                                        | 'die.face.6'
                                                                                                                                                                                                                                                                                                                        | 'die.face.6.fill'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.arrow.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.arrow.clockwise.fill'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.arrow.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.arrow.counterclockwise.fill'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.fill'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.horizontal.arrow.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.horizontal.arrow.clockwise.fill'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.horizontal.arrow.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.horizontal.arrow.counterclockwise.fill'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.horizontal.press'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.horizontal.press.fill'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.press'
                                                                                                                                                                                                                                                                                                                        | 'digitalcrown.press.fill'
                                                                                                                                                                                                                                                                                                                        | 'directcurrent'
                                                                                                                                                                                                                                                                                                                        | 'dishwasher'
                                                                                                                                                                                                                                                                                                                        | 'dishwasher.circle'
                                                                                                                                                                                                                                                                                                                        | 'dishwasher.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'dishwasher.fill'
                                                                                                                                                                                                                                                                                                                        | 'display'
                                                                                                                                                                                                                                                                                                                        | 'display.2'
                                                                                                                                                                                                                                                                                                                        | 'display.and.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'display.and.screwdriver'
                                                                                                                                                                                                                                                                                                                        | 'display.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'distribute.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'distribute.horizontal.center'
                                                                                                                                                                                                                                                                                                                        | 'distribute.horizontal.center.fill'
                                                                                                                                                                                                                                                                                                                        | 'distribute.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'distribute.horizontal.left'
                                                                                                                                                                                                                                                                                                                        | 'distribute.horizontal.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'distribute.horizontal.right'
                                                                                                                                                                                                                                                                                                                        | 'distribute.horizontal.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'distribute.vertical'
                                                                                                                                                                                                                                                                                                                        | 'distribute.vertical.bottom'
                                                                                                                                                                                                                                                                                                                        | 'distribute.vertical.bottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'distribute.vertical.center'
                                                                                                                                                                                                                                                                                                                        | 'distribute.vertical.center.fill'
                                                                                                                                                                                                                                                                                                                        | 'distribute.vertical.fill'
                                                                                                                                                                                                                                                                                                                        | 'distribute.vertical.top'
                                                                                                                                                                                                                                                                                                                        | 'distribute.vertical.top.fill'
                                                                                                                                                                                                                                                                                                                        | 'divide'
                                                                                                                                                                                                                                                                                                                        | 'divide.circle'
                                                                                                                                                                                                                                                                                                                        | 'divide.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'divide.square'
                                                                                                                                                                                                                                                                                                                        | 'divide.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc'
                                                                                                                                                                                                                                                                                                                        | 'doc.append'
                                                                                                                                                                                                                                                                                                                        | 'doc.append.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.append.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'doc.append.rtl'
                                                                                                                                                                                                                                                                                                                        | 'doc.badge.arrow.up'
                                                                                                                                                                                                                                                                                                                        | 'doc.badge.arrow.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'doc.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'doc.badge.gearshape'
                                                                                                                                                                                                                                                                                                                        | 'doc.badge.gearshape.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'doc.circle'
                                                                                                                                                                                                                                                                                                                        | 'doc.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.fill.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'doc.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'doc.on.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'doc.on.clipboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.on.doc'
                                                                                                                                                                                                                                                                                                                        | 'doc.on.doc.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.plaintext'
                                                                                                                                                                                                                                                                                                                        | 'doc.plaintext.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'doc.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'doc.questionmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.questionmark.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'doc.questionmark.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'doc.questionmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.ar'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.fill.he'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.fill.hi'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.fill.ja'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.fill.ko'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.fill.th'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.fill.zh'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.he'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.hi'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.ja'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.ko'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.th'
                                                                                                                                                                                                                                                                                                                        | 'doc.richtext.zh'
                                                                                                                                                                                                                                                                                                                        | 'doc.text'
                                                                                                                                                                                                                                                                                                                        | 'doc.text.below.ecg'
                                                                                                                                                                                                                                                                                                                        | 'doc.text.below.ecg.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.text.below.ecg.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'doc.text.below.ecg.rtl'
                                                                                                                                                                                                                                                                                                                        | 'doc.text.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.text.fill.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'doc.text.image'
                                                                                                                                                                                                                                                                                                                        | 'doc.text.image.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.text.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'doc.text.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'doc.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'doc.viewfinder.fill'
                                                                                                                                                                                                                                                                                                                        | 'doc.zipper'
                                                                                                                                                                                                                                                                                                                        | 'dock.arrow.down.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'dock.arrow.up.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'dock.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'document'
                                                                                                                                                                                                                                                                                                                        | 'document.badge.arrow.up'
                                                                                                                                                                                                                                                                                                                        | 'document.badge.arrow.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'document.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'document.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'document.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'document.badge.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'document.badge.gearshape'
                                                                                                                                                                                                                                                                                                                        | 'document.badge.gearshape.fill'
                                                                                                                                                                                                                                                                                                                        | 'document.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'document.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'document.circle'
                                                                                                                                                                                                                                                                                                                        | 'document.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'document.fill'
                                                                                                                                                                                                                                                                                                                        | 'document.on.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'document.on.clipboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'document.on.document'
                                                                                                                                                                                                                                                                                                                        | 'document.on.document.fill'
                                                                                                                                                                                                                                                                                                                        | 'document.on.trash'
                                                                                                                                                                                                                                                                                                                        | 'document.on.trash.fill'
                                                                                                                                                                                                                                                                                                                        | 'document.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'document.viewfinder.fill'
                                                                                                                                                                                                                                                                                                                        | 'dog'
                                                                                                                                                                                                                                                                                                                        | 'dog.circle'
                                                                                                                                                                                                                                                                                                                        | 'dog.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'dog.fill'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.square'
                                                                                                                                                                                                                                                                                                                        | 'dollarsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'dongsign'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.square'
                                                                                                                                                                                                                                                                                                                        | 'dongsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'door.french.closed'
                                                                                                                                                                                                                                                                                                                        | 'door.french.open'
                                                                                                                                                                                                                                                                                                                        | 'door.garage.closed'
                                                                                                                                                                                                                                                                                                                        | 'door.garage.closed.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'door.garage.double.bay.closed'
                                                                                                                                                                                                                                                                                                                        | 'door.garage.double.bay.closed.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'door.garage.double.bay.open'
                                                                                                                                                                                                                                                                                                                        | 'door.garage.double.bay.open.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'door.garage.open'
                                                                                                                                                                                                                                                                                                                        | 'door.garage.open.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'door.left.hand.closed'
                                                                                                                                                                                                                                                                                                                        | 'door.left.hand.open'
                                                                                                                                                                                                                                                                                                                        | 'door.right.hand.closed'
                                                                                                                                                                                                                                                                                                                        | 'door.right.hand.open'
                                                                                                                                                                                                                                                                                                                        | 'door.sliding.left.hand.closed'
                                                                                                                                                                                                                                                                                                                        | 'door.sliding.left.hand.open'
                                                                                                                                                                                                                                                                                                                        | 'door.sliding.right.hand.closed'
                                                                                                                                                                                                                                                                                                                        | 'door.sliding.right.hand.open'
                                                                                                                                                                                                                                                                                                                        | 'dot.arrowtriangles.up.right.down.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'dot.car.top.radiowaves.2.rear.left.rear.rear.right'
                                                                                                                                                                                                                                                                                                                        | 'dot.car.top.radiowaves.2.rear.left.rear.rear.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'dot.circle.and.cursorarrow'
                                                                                                                                                                                                                                                                                                                        | 'dot.circle.and.hand.point.up.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'dot.circle.and.pointer.arrow'
                                                                                                                                                                                                                                                                                                                        | 'dot.circle.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'dot.crosshair'
                                                                                                                                                                                                                                                                                                                        | 'dot.radiowaves.forward'
                                                                                                                                                                                                                                                                                                                        | 'dot.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'dot.radiowaves.right'
                                                                                                                                                                                                                                                                                                                        | 'dot.radiowaves.up.forward'
                                                                                                                                                                                                                                                                                                                        | 'dot.scope'
                                                                                                                                                                                                                                                                                                                        | 'dot.scope.display'
                                                                                                                                                                                                                                                                                                                        | 'dot.scope.laptopcomputer'
                                                                                                                                                                                                                                                                                                                        | 'dot.square'
                                                                                                                                                                                                                                                                                                                        | 'dot.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'dot.squareshape'
                                                                                                                                                                                                                                                                                                                        | 'dot.squareshape.fill'
                                                                                                                                                                                                                                                                                                                        | 'dot.squareshape.split.2x2'
                                                                                                                                                                                                                                                                                                                        | 'dot.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'dots.and.line.vertical.and.cursorarrow.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'dots.and.line.vertical.and.pointer.arrow.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'dpad'
                                                                                                                                                                                                                                                                                                                        | 'dpad.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'dpad.down.filled'
                                                                                                                                                                                                                                                                                                                        | 'dpad.fill'
                                                                                                                                                                                                                                                                                                                        | 'dpad.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'dpad.left.filled'
                                                                                                                                                                                                                                                                                                                        | 'dpad.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'dpad.right.filled'
                                                                                                                                                                                                                                                                                                                        | 'dpad.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'dpad.up.filled'
                                                                                                                                                                                                                                                                                                                        | 'drone'
                                                                                                                                                                                                                                                                                                                        | 'drone.fill'
                                                                                                                                                                                                                                                                                                                        | 'drop'
                                                                                                                                                                                                                                                                                                                        | 'drop.circle'
                                                                                                                                                                                                                                                                                                                        | 'drop.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'drop.degreesign'
                                                                                                                                                                                                                                                                                                                        | 'drop.degreesign.fill'
                                                                                                                                                                                                                                                                                                                        | 'drop.degreesign.slash'
                                                                                                                                                                                                                                                                                                                        | 'drop.degreesign.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'drop.degreesign.slash.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'drop.degreesign.slash.rtl'
                                                                                                                                                                                                                                                                                                                        | 'drop.fill'
                                                                                                                                                                                                                                                                                                                        | 'drop.halffull'
                                                                                                                                                                                                                                                                                                                        | 'drop.keypad.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'drop.keypad.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'drop.transmission'
                                                                                                                                                                                                                                                                                                                        | 'drop.triangle'
                                                                                                                                                                                                                                                                                                                        | 'drop.triangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'dryer'
                                                                                                                                                                                                                                                                                                                        | 'dryer.circle'
                                                                                                                                                                                                                                                                                                                        | 'dryer.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'dryer.fill'
                                                                                                                                                                                                                                                                                                                        | 'duffle.bag'
                                                                                                                                                                                                                                                                                                                        | 'duffle.bag.fill'
                                                                                                                                                                                                                                                                                                                        | 'dumbbell'
                                                                                                                                                                                                                                                                                                                        | 'dumbbell.fill'
                                                                                                                                                                                                                                                                                                                        | 'e.circle'
                                                                                                                                                                                                                                                                                                                        | 'e.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'e.square'
                                                                                                                                                                                                                                                                                                                        | 'e.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'ear'
                                                                                                                                                                                                                                                                                                                        | 'ear.and.waveform'
                                                                                                                                                                                                                                                                                                                        | 'ear.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'ear.badge.waveform'
                                                                                                                                                                                                                                                                                                                        | 'ear.fill'
                                                                                                                                                                                                                                                                                                                        | 'ear.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'earbud.left'
                                                                                                                                                                                                                                                                                                                        | 'earbud.right'
                                                                                                                                                                                                                                                                                                                        | 'earbuds'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.bone.conduction'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.bone.conduction.left'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.bone.conduction.right'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.case'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.case.fill'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.in.ear'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.in.ear.left'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.in.ear.right'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.stemless'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.stemless.left'
                                                                                                                                                                                                                                                                                                                        | 'earbuds.stemless.right'
                                                                                                                                                                                                                                                                                                                        | 'earpods'
                                                                                                                                                                                                                                                                                                                        | 'ecg.text.page'
                                                                                                                                                                                                                                                                                                                        | 'ecg.text.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'ecg.text.page.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'ecg.text.page.rtl'
                                                                                                                                                                                                                                                                                                                        | 'eject'
                                                                                                                                                                                                                                                                                                                        | 'eject.circle'
                                                                                                                                                                                                                                                                                                                        | 'eject.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'eject.fill'
                                                                                                                                                                                                                                                                                                                        | 'electronic.toll.collection'
                                                                                                                                                                                                                                                                                                                        | 'electronic.toll.collection.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'electronic.toll.collection.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'electronic.toll.collection.rectangle.slash'
                                                                                                                                                                                                                                                                                                                        | 'electronic.toll.collection.rectangle.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'electronic.toll.collection.rectangle.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'electronic.toll.collection.rectangle.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'ellipses.bubble'
                                                                                                                                                                                                                                                                                                                        | 'ellipses.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.bubble'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.calendar'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.circle'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.circle.badge'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.circle.badge.fill'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.curlybraces'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.message'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.message.fill'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.vertical.bubble'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.vertical.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'ellipsis.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'engine.combustion'
                                                                                                                                                                                                                                                                                                                        | 'engine.combustion.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'engine.combustion.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'engine.combustion.fill'
                                                                                                                                                                                                                                                                                                                        | 'engine.emission.and.drop.2.water.wave.below'
                                                                                                                                                                                                                                                                                                                        | 'engine.emission.and.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'engine.emission.and.filter'
                                                                                                                                                                                                                                                                                                                        | 'entry.lever.keypad'
                                                                                                                                                                                                                                                                                                                        | 'entry.lever.keypad.fill'
                                                                                                                                                                                                                                                                                                                        | 'entry.lever.keypad.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'entry.lever.keypad.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope'
                                                                                                                                                                                                                                                                                                                        | 'envelope.and.arrow.3.down'
                                                                                                                                                                                                                                                                                                                        | 'envelope.and.arrow.3.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.and.arrow.trianglehead.branch'
                                                                                                                                                                                                                                                                                                                        | 'envelope.and.arrow.trianglehead.branch.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.and.hand.raised'
                                                                                                                                                                                                                                                                                                                        | 'envelope.and.hand.raised.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.arrow.triangle.branch'
                                                                                                                                                                                                                                                                                                                        | 'envelope.arrow.triangle.branch.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge.person.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge.shield.half.filled'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge.shield.half.filled.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.badge.shield.leadinghalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.circle'
                                                                                                                                                                                                                                                                                                                        | 'envelope.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.fill.badge.shield.trailinghalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.front'
                                                                                                                                                                                                                                                                                                                        | 'envelope.front.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.front.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'envelope.front.rtl'
                                                                                                                                                                                                                                                                                                                        | 'envelope.open'
                                                                                                                                                                                                                                                                                                                        | 'envelope.open.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'envelope.open.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'envelope.stack'
                                                                                                                                                                                                                                                                                                                        | 'envelope.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'environments'
                                                                                                                                                                                                                                                                                                                        | 'environments.circle'
                                                                                                                                                                                                                                                                                                                        | 'environments.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'environments.fill'
                                                                                                                                                                                                                                                                                                                        | 'environments.slash'
                                                                                                                                                                                                                                                                                                                        | 'environments.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'environments.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'environments.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'equal'
                                                                                                                                                                                                                                                                                                                        | 'equal.circle'
                                                                                                                                                                                                                                                                                                                        | 'equal.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'equal.square'
                                                                                                                                                                                                                                                                                                                        | 'equal.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'eraser'
                                                                                                                                                                                                                                                                                                                        | 'eraser.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'eraser.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'eraser.fill'
                                                                                                                                                                                                                                                                                                                        | 'eraser.line.dashed'
                                                                                                                                                                                                                                                                                                                        | 'eraser.line.dashed.fill'
                                                                                                                                                                                                                                                                                                                        | 'eraser.slash'
                                                                                                                                                                                                                                                                                                                        | 'eraser.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'eraser.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'eraser.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'escape'
                                                                                                                                                                                                                                                                                                                        | 'esim'
                                                                                                                                                                                                                                                                                                                        | 'esim.fill'
                                                                                                                                                                                                                                                                                                                        | 'eurosign'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.circle'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.ring'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.square'
                                                                                                                                                                                                                                                                                                                        | 'eurosign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.circle'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.ring'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.square'
                                                                                                                                                                                                                                                                                                                        | 'eurozonesign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.charger'
                                                                                                                                                                                                                                                                                                                        | 'ev.charger.arrowtriangle.left'
                                                                                                                                                                                                                                                                                                                        | 'ev.charger.arrowtriangle.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.charger.arrowtriangle.right'
                                                                                                                                                                                                                                                                                                                        | 'ev.charger.arrowtriangle.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.charger.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'ev.charger.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.charger.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.charger.slash'
                                                                                                                                                                                                                                                                                                                        | 'ev.charger.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.ac.gb.t'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.ac.gb.t.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.ac.type.1'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.ac.type.1.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.ac.type.2'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.ac.type.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.dc.ccs1'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.dc.ccs1.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.dc.ccs2'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.dc.ccs2.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.dc.chademo'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.dc.chademo.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.dc.gb.t'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.dc.gb.t.fill'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.dc.nacs'
                                                                                                                                                                                                                                                                                                                        | 'ev.plug.dc.nacs.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.2'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.3'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.applewatch'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.arrow.triangle.2.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.arrow.trianglehead.2.clockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.bubble'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.bubble.circle'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.bubble.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.circle'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.icloud'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.lock'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.lock.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.message'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.message.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.octagon'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.octagon.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.shield'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.square'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.tirepressure'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.transmission'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.triangle'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.triangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.triangle.text.page'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.triangle.text.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.triangle.text.page.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.triangle.text.page.rtl'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.warninglight'
                                                                                                                                                                                                                                                                                                                        | 'exclamationmark.warninglight.fill'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.icloud'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.timemachine'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.wifi'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.connected.to.line.below'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.connected.to.line.below.fill'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.icloud'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.timemachine'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.wifi'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.fill.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'externaldrive.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'eye'
                                                                                                                                                                                                                                                                                                                        | 'eye.circle'
                                                                                                                                                                                                                                                                                                                        | 'eye.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'eye.fill'
                                                                                                                                                                                                                                                                                                                        | 'eye.half.closed'
                                                                                                                                                                                                                                                                                                                        | 'eye.half.closed.fill'
                                                                                                                                                                                                                                                                                                                        | 'eye.slash'
                                                                                                                                                                                                                                                                                                                        | 'eye.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'eye.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'eye.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'eye.square'
                                                                                                                                                                                                                                                                                                                        | 'eye.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'eye.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'eye.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'eyebrow'
                                                                                                                                                                                                                                                                                                                        | 'eyedropper'
                                                                                                                                                                                                                                                                                                                        | 'eyedropper.and.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'eyedropper.full'
                                                                                                                                                                                                                                                                                                                        | 'eyedropper.halffull'
                                                                                                                                                                                                                                                                                                                        | 'eyeglasses'
                                                                                                                                                                                                                                                                                                                        | 'eyeglasses.slash'
                                                                                                                                                                                                                                                                                                                        | 'eyes'
                                                                                                                                                                                                                                                                                                                        | 'eyes.inverse'
                                                                                                                                                                                                                                                                                                                        | 'f.circle'
                                                                                                                                                                                                                                                                                                                        | 'f.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'f.cursive'
                                                                                                                                                                                                                                                                                                                        | 'f.cursive.circle'
                                                                                                                                                                                                                                                                                                                        | 'f.cursive.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'f.cursive.slash'
                                                                                                                                                                                                                                                                                                                        | 'f.square'
                                                                                                                                                                                                                                                                                                                        | 'f.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'face.dashed'
                                                                                                                                                                                                                                                                                                                        | 'face.dashed.fill'
                                                                                                                                                                                                                                                                                                                        | 'face.smiling'
                                                                                                                                                                                                                                                                                                                        | 'face.smiling.fill'
                                                                                                                                                                                                                                                                                                                        | 'face.smiling.inverse'
                                                                                                                                                                                                                                                                                                                        | 'faceid'
                                                                                                                                                                                                                                                                                                                        | 'facemask'
                                                                                                                                                                                                                                                                                                                        | 'facemask.fill'
                                                                                                                                                                                                                                                                                                                        | 'fan'
                                                                                                                                                                                                                                                                                                                        | 'fan.and.light.ceiling'
                                                                                                                                                                                                                                                                                                                        | 'fan.and.light.ceiling.fill'
                                                                                                                                                                                                                                                                                                                        | 'fan.badge.arrow.up.and.down.and.arrow.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'fan.badge.arrow.up.and.down.and.arrow.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'fan.badge.automatic'
                                                                                                                                                                                                                                                                                                                        | 'fan.badge.automatic.fill'
                                                                                                                                                                                                                                                                                                                        | 'fan.ceiling'
                                                                                                                                                                                                                                                                                                                        | 'fan.ceiling.fill'
                                                                                                                                                                                                                                                                                                                        | 'fan.circle'
                                                                                                                                                                                                                                                                                                                        | 'fan.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'fan.desk'
                                                                                                                                                                                                                                                                                                                        | 'fan.desk.fill'
                                                                                                                                                                                                                                                                                                                        | 'fan.fill'
                                                                                                                                                                                                                                                                                                                        | 'fan.floor'
                                                                                                                                                                                                                                                                                                                        | 'fan.floor.fill'
                                                                                                                                                                                                                                                                                                                        | 'fan.gauge.open'
                                                                                                                                                                                                                                                                                                                        | 'fan.oscillation'
                                                                                                                                                                                                                                                                                                                        | 'fan.oscillation.fill'
                                                                                                                                                                                                                                                                                                                        | 'fan.slash'
                                                                                                                                                                                                                                                                                                                        | 'fan.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'fanblades'
                                                                                                                                                                                                                                                                                                                        | 'fanblades.fill'
                                                                                                                                                                                                                                                                                                                        | 'fanblades.slash'
                                                                                                                                                                                                                                                                                                                        | 'fanblades.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'faxmachine'
                                                                                                                                                                                                                                                                                                                        | 'faxmachine.fill'
                                                                                                                                                                                                                                                                                                                        | 'ferry'
                                                                                                                                                                                                                                                                                                                        | 'ferry.fill'
                                                                                                                                                                                                                                                                                                                        | 'fiberchannel'
                                                                                                                                                                                                                                                                                                                        | 'fibrechannel'
                                                                                                                                                                                                                                                                                                                        | 'field.of.view.ultrawide'
                                                                                                                                                                                                                                                                                                                        | 'field.of.view.ultrawide.fill'
                                                                                                                                                                                                                                                                                                                        | 'field.of.view.wide'
                                                                                                                                                                                                                                                                                                                        | 'field.of.view.wide.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure'
                                                                                                                                                                                                                                                                                                                        | 'figure.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.2.and.child.holdinghands'
                                                                                                                                                                                                                                                                                                                        | 'figure.2.arms.open'
                                                                                                                                                                                                                                                                                                                        | 'figure.2.ascending'
                                                                                                                                                                                                                                                                                                                        | 'figure.2.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.2.descending'
                                                                                                                                                                                                                                                                                                                        | 'figure.2.left.holdinghands'
                                                                                                                                                                                                                                                                                                                        | 'figure.2.right.holdinghands'
                                                                                                                                                                                                                                                                                                                        | 'figure.american.football'
                                                                                                                                                                                                                                                                                                                        | 'figure.american.football.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.american.football.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.and.child.holdinghands'
                                                                                                                                                                                                                                                                                                                        | 'figure.archery'
                                                                                                                                                                                                                                                                                                                        | 'figure.archery.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.archery.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.arms.open'
                                                                                                                                                                                                                                                                                                                        | 'figure.australian.football'
                                                                                                                                                                                                                                                                                                                        | 'figure.australian.football.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.australian.football.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.badminton'
                                                                                                                                                                                                                                                                                                                        | 'figure.badminton.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.badminton.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.barre'
                                                                                                                                                                                                                                                                                                                        | 'figure.barre.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.barre.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.baseball'
                                                                                                                                                                                                                                                                                                                        | 'figure.baseball.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.baseball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.basketball'
                                                                                                                                                                                                                                                                                                                        | 'figure.basketball.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.basketball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.bowling'
                                                                                                                                                                                                                                                                                                                        | 'figure.bowling.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.bowling.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.boxing'
                                                                                                                                                                                                                                                                                                                        | 'figure.boxing.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.boxing.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.child'
                                                                                                                                                                                                                                                                                                                        | 'figure.child.and.lock'
                                                                                                                                                                                                                                                                                                                        | 'figure.child.and.lock.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.child.and.lock.open'
                                                                                                                                                                                                                                                                                                                        | 'figure.child.and.lock.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.child.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.child.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.child.shield'
                                                                                                                                                                                                                                                                                                                        | 'figure.child.shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.climbing'
                                                                                                                                                                                                                                                                                                                        | 'figure.climbing.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.climbing.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.cooldown'
                                                                                                                                                                                                                                                                                                                        | 'figure.cooldown.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.cooldown.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.core.training'
                                                                                                                                                                                                                                                                                                                        | 'figure.core.training.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.core.training.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.cricket'
                                                                                                                                                                                                                                                                                                                        | 'figure.cricket.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.cricket.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.cross.training'
                                                                                                                                                                                                                                                                                                                        | 'figure.cross.training.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.cross.training.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.curling'
                                                                                                                                                                                                                                                                                                                        | 'figure.curling.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.curling.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.dance'
                                                                                                                                                                                                                                                                                                                        | 'figure.dance.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.dance.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.disc.sports'
                                                                                                                                                                                                                                                                                                                        | 'figure.disc.sports.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.disc.sports.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.dress.line.vertical.figure'
                                                                                                                                                                                                                                                                                                                        | 'figure.elliptical'
                                                                                                                                                                                                                                                                                                                        | 'figure.elliptical.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.elliptical.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.equestrian.sports'
                                                                                                                                                                                                                                                                                                                        | 'figure.equestrian.sports.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.equestrian.sports.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.fall'
                                                                                                                                                                                                                                                                                                                        | 'figure.fall.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.fall.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.fencing'
                                                                                                                                                                                                                                                                                                                        | 'figure.fencing.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.fencing.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.field.hockey'
                                                                                                                                                                                                                                                                                                                        | 'figure.field.hockey.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.field.hockey.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.fishing'
                                                                                                                                                                                                                                                                                                                        | 'figure.fishing.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.fishing.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.flexibility'
                                                                                                                                                                                                                                                                                                                        | 'figure.flexibility.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.flexibility.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.golf'
                                                                                                                                                                                                                                                                                                                        | 'figure.golf.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.golf.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.gymnastics'
                                                                                                                                                                                                                                                                                                                        | 'figure.gymnastics.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.gymnastics.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.hand.cycling'
                                                                                                                                                                                                                                                                                                                        | 'figure.hand.cycling.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.hand.cycling.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.handball'
                                                                                                                                                                                                                                                                                                                        | 'figure.handball.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.handball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.highintensity.intervaltraining'
                                                                                                                                                                                                                                                                                                                        | 'figure.highintensity.intervaltraining.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.highintensity.intervaltraining.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.hiking'
                                                                                                                                                                                                                                                                                                                        | 'figure.hiking.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.hiking.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.hockey'
                                                                                                                                                                                                                                                                                                                        | 'figure.hockey.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.hockey.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.hunting'
                                                                                                                                                                                                                                                                                                                        | 'figure.hunting.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.hunting.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.ice.hockey'
                                                                                                                                                                                                                                                                                                                        | 'figure.ice.hockey.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.ice.hockey.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.ice.skating'
                                                                                                                                                                                                                                                                                                                        | 'figure.ice.skating.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.ice.skating.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.indoor.cycle'
                                                                                                                                                                                                                                                                                                                        | 'figure.indoor.cycle.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.indoor.cycle.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.indoor.rowing'
                                                                                                                                                                                                                                                                                                                        | 'figure.indoor.rowing.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.indoor.rowing.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.indoor.soccer'
                                                                                                                                                                                                                                                                                                                        | 'figure.indoor.soccer.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.indoor.soccer.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.jumprope'
                                                                                                                                                                                                                                                                                                                        | 'figure.jumprope.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.jumprope.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.kickboxing'
                                                                                                                                                                                                                                                                                                                        | 'figure.kickboxing.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.kickboxing.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.lacrosse'
                                                                                                                                                                                                                                                                                                                        | 'figure.lacrosse.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.lacrosse.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.martial.arts'
                                                                                                                                                                                                                                                                                                                        | 'figure.martial.arts.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.martial.arts.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.mind.and.body'
                                                                                                                                                                                                                                                                                                                        | 'figure.mind.and.body.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.mind.and.body.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.mixed.cardio'
                                                                                                                                                                                                                                                                                                                        | 'figure.mixed.cardio.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.mixed.cardio.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.open.water.swim'
                                                                                                                                                                                                                                                                                                                        | 'figure.open.water.swim.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.open.water.swim.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.outdoor.cycle'
                                                                                                                                                                                                                                                                                                                        | 'figure.outdoor.cycle.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.outdoor.cycle.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.outdoor.rowing'
                                                                                                                                                                                                                                                                                                                        | 'figure.outdoor.rowing.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.outdoor.rowing.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.outdoor.soccer'
                                                                                                                                                                                                                                                                                                                        | 'figure.outdoor.soccer.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.outdoor.soccer.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.pickleball'
                                                                                                                                                                                                                                                                                                                        | 'figure.pickleball.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.pickleball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.pilates'
                                                                                                                                                                                                                                                                                                                        | 'figure.pilates.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.pilates.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.play'
                                                                                                                                                                                                                                                                                                                        | 'figure.play.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.play.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.pool.swim'
                                                                                                                                                                                                                                                                                                                        | 'figure.pool.swim.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.pool.swim.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.racquetball'
                                                                                                                                                                                                                                                                                                                        | 'figure.racquetball.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.racquetball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.roll'
                                                                                                                                                                                                                                                                                                                        | 'figure.roll.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.roll.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.roll.runningpace'
                                                                                                                                                                                                                                                                                                                        | 'figure.roll.runningpace.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.roll.runningpace.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.rolling'
                                                                                                                                                                                                                                                                                                                        | 'figure.rolling.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.rolling.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.rower'
                                                                                                                                                                                                                                                                                                                        | 'figure.rugby'
                                                                                                                                                                                                                                                                                                                        | 'figure.rugby.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.rugby.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.run'
                                                                                                                                                                                                                                                                                                                        | 'figure.run.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.run.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.run.square.stack'
                                                                                                                                                                                                                                                                                                                        | 'figure.run.square.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.run.treadmill'
                                                                                                                                                                                                                                                                                                                        | 'figure.run.treadmill.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.run.treadmill.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.sailing'
                                                                                                                                                                                                                                                                                                                        | 'figure.sailing.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.sailing.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.and.airbag.off'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.and.airbag.on'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.1'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.1.1'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.1.1.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.1.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.1.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.1.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.2.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.2.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.2.3'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.2.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.3'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.3.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.3.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.3.3'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.3.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.3'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.3.3'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.3.3.3'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.3.3.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.3.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.seatbelt.left.drive.seats.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.distribution.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.distribution.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.distribution.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.distribution.middle.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.distribution.upper'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.distribution.upper.angled.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.distribution.upper.angled.and.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.distribution.upper.angled.and.middle.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.upper'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.upper.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.air.windshield'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.airbag.off'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.airbag.off.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.airbag.on'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.airbag.on.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.automatic'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.indirect'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.lower.angled.and.upper.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.middle.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.upper'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.upper.and.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.upper.angled.and.dottedline.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.upper.angled.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.upper.angled.and.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.air.distribution.upper.angled.and.middle.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.airbag.off'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.airbag.off.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.airbag.on'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.airbag.on.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.automatic'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.fan'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.steeringwheel'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.windshield.front.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.upper'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.upper.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.upper.and.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.upper.and.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.indirect'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.lower.angled.and.upper.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.middle.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.upper'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.upper.and.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.upper.angled.and.dottedline.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.upper.angled.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.upper.angled.and.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.air.distribution.upper.angled.and.middle.and.lower.angled'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.airbag.off'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.airbag.off.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.airbag.on'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.airbag.on.2'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.automatic'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.child.lap'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.fan'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.steeringwheel'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.windshield.front.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.upper'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.upper.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.upper.and.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.upper.and.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.windshield.front.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.windshield.front.and.heat.waves.air.distribution.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.windshield.front.and.heat.waves.air.distribution.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.windshield.front.and.heat.waves.air.distribution.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.windshield.front.and.heat.waves.air.distribution.upper'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.windshield.front.and.heat.waves.air.distribution.upper.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.windshield.front.and.heat.waves.air.distribution.upper.and.middle'
                                                                                                                                                                                                                                                                                                                        | 'figure.seated.side.windshield.front.and.heat.waves.air.distribution.upper.and.middle.and.lower'
                                                                                                                                                                                                                                                                                                                        | 'figure.skateboarding'
                                                                                                                                                                                                                                                                                                                        | 'figure.skateboarding.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.skateboarding.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.skating'
                                                                                                                                                                                                                                                                                                                        | 'figure.skiing.crosscountry'
                                                                                                                                                                                                                                                                                                                        | 'figure.skiing.crosscountry.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.skiing.crosscountry.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.skiing.downhill'
                                                                                                                                                                                                                                                                                                                        | 'figure.skiing.downhill.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.skiing.downhill.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.snowboarding'
                                                                                                                                                                                                                                                                                                                        | 'figure.snowboarding.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.snowboarding.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.soccer'
                                                                                                                                                                                                                                                                                                                        | 'figure.socialdance'
                                                                                                                                                                                                                                                                                                                        | 'figure.socialdance.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.socialdance.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.softball'
                                                                                                                                                                                                                                                                                                                        | 'figure.softball.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.softball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.squash'
                                                                                                                                                                                                                                                                                                                        | 'figure.squash.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.squash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.stair.stepper'
                                                                                                                                                                                                                                                                                                                        | 'figure.stair.stepper.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.stair.stepper.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.stairs'
                                                                                                                                                                                                                                                                                                                        | 'figure.stairs.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.stairs.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.stand'
                                                                                                                                                                                                                                                                                                                        | 'figure.stand.and.figure.teen'
                                                                                                                                                                                                                                                                                                                        | 'figure.stand.dress'
                                                                                                                                                                                                                                                                                                                        | 'figure.stand.dress.line.vertical.figure'
                                                                                                                                                                                                                                                                                                                        | 'figure.stand.line.dotted.figure.stand'
                                                                                                                                                                                                                                                                                                                        | 'figure.step.training'
                                                                                                                                                                                                                                                                                                                        | 'figure.step.training.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.step.training.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.strengthtraining.functional'
                                                                                                                                                                                                                                                                                                                        | 'figure.strengthtraining.functional.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.strengthtraining.functional.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.strengthtraining.traditional'
                                                                                                                                                                                                                                                                                                                        | 'figure.strengthtraining.traditional.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.strengthtraining.traditional.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.surfing'
                                                                                                                                                                                                                                                                                                                        | 'figure.surfing.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.surfing.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.table.tennis'
                                                                                                                                                                                                                                                                                                                        | 'figure.table.tennis.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.table.tennis.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.taichi'
                                                                                                                                                                                                                                                                                                                        | 'figure.taichi.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.taichi.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.teen'
                                                                                                                                                                                                                                                                                                                        | 'figure.teen.and.lock'
                                                                                                                                                                                                                                                                                                                        | 'figure.teen.and.lock.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.teen.and.lock.open'
                                                                                                                                                                                                                                                                                                                        | 'figure.teen.and.lock.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.teen.shield'
                                                                                                                                                                                                                                                                                                                        | 'figure.teen.shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.tennis'
                                                                                                                                                                                                                                                                                                                        | 'figure.tennis.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.tennis.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.track.and.field'
                                                                                                                                                                                                                                                                                                                        | 'figure.track.and.field.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.track.and.field.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.volleyball'
                                                                                                                                                                                                                                                                                                                        | 'figure.volleyball.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.volleyball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.arrival'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.departure'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.diamond'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.motion'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.motion.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.suitcase.rolling'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.suitcase.rolling.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.suitcase.rolling.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.treadmill'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.treadmill.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.treadmill.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.triangle'
                                                                                                                                                                                                                                                                                                                        | 'figure.walk.triangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.water.fitness'
                                                                                                                                                                                                                                                                                                                        | 'figure.water.fitness.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.water.fitness.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.waterpolo'
                                                                                                                                                                                                                                                                                                                        | 'figure.waterpolo.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.waterpolo.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.wave'
                                                                                                                                                                                                                                                                                                                        | 'figure.wave.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.wave.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.wrestling'
                                                                                                                                                                                                                                                                                                                        | 'figure.wrestling.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.wrestling.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'figure.yoga'
                                                                                                                                                                                                                                                                                                                        | 'figure.yoga.circle'
                                                                                                                                                                                                                                                                                                                        | 'figure.yoga.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'filemenu.and.cursorarrow'
                                                                                                                                                                                                                                                                                                                        | 'filemenu.and.cursorarrow.rtl'
                                                                                                                                                                                                                                                                                                                        | 'filemenu.and.pointer.arrow'
                                                                                                                                                                                                                                                                                                                        | 'filemenu.and.pointer.arrow.rtl'
                                                                                                                                                                                                                                                                                                                        | 'filemenu.and.selection'
                                                                                                                                                                                                                                                                                                                        | 'film'
                                                                                                                                                                                                                                                                                                                        | 'film.circle'
                                                                                                                                                                                                                                                                                                                        | 'film.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'film.fill'
                                                                                                                                                                                                                                                                                                                        | 'film.stack'
                                                                                                                                                                                                                                                                                                                        | 'film.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'finder'
                                                                                                                                                                                                                                                                                                                        | 'fire.extinguisher'
                                                                                                                                                                                                                                                                                                                        | 'fire.extinguisher.fill'
                                                                                                                                                                                                                                                                                                                        | 'fireplace'
                                                                                                                                                                                                                                                                                                                        | 'fireplace.fill'
                                                                                                                                                                                                                                                                                                                        | 'firewall'
                                                                                                                                                                                                                                                                                                                        | 'firewall.fill'
                                                                                                                                                                                                                                                                                                                        | 'fireworks'
                                                                                                                                                                                                                                                                                                                        | 'fish'
                                                                                                                                                                                                                                                                                                                        | 'fish.circle'
                                                                                                                                                                                                                                                                                                                        | 'fish.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'fish.fill'
                                                                                                                                                                                                                                                                                                                        | 'flag'
                                                                                                                                                                                                                                                                                                                        | 'flag.2.crossed'
                                                                                                                                                                                                                                                                                                                        | 'flag.2.crossed.circle'
                                                                                                                                                                                                                                                                                                                        | 'flag.2.crossed.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'flag.2.crossed.fill'
                                                                                                                                                                                                                                                                                                                        | 'flag.and.flag.filled.crossed'
                                                                                                                                                                                                                                                                                                                        | 'flag.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'flag.badge.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'flag.checkered'
                                                                                                                                                                                                                                                                                                                        | 'flag.checkered.2.crossed'
                                                                                                                                                                                                                                                                                                                        | 'flag.checkered.circle'
                                                                                                                                                                                                                                                                                                                        | 'flag.checkered.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'flag.circle'
                                                                                                                                                                                                                                                                                                                        | 'flag.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'flag.fill'
                                                                                                                                                                                                                                                                                                                        | 'flag.filled.and.flag.crossed'
                                                                                                                                                                                                                                                                                                                        | 'flag.pattern.checkered'
                                                                                                                                                                                                                                                                                                                        | 'flag.pattern.checkered.2.crossed'
                                                                                                                                                                                                                                                                                                                        | 'flag.pattern.checkered.circle'
                                                                                                                                                                                                                                                                                                                        | 'flag.pattern.checkered.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'flag.pattern.checkered.lc'
                                                                                                                                                                                                                                                                                                                        | 'flag.slash'
                                                                                                                                                                                                                                                                                                                        | 'flag.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'flag.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'flag.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'flag.square'
                                                                                                                                                                                                                                                                                                                        | 'flag.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'flame'
                                                                                                                                                                                                                                                                                                                        | 'flame.circle'
                                                                                                                                                                                                                                                                                                                        | 'flame.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'flame.fill'
                                                                                                                                                                                                                                                                                                                        | 'flame.gauge.open'
                                                                                                                                                                                                                                                                                                                        | 'flashlight.off.circle'
                                                                                                                                                                                                                                                                                                                        | 'flashlight.off.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'flashlight.off.fill'
                                                                                                                                                                                                                                                                                                                        | 'flashlight.on.circle'
                                                                                                                                                                                                                                                                                                                        | 'flashlight.on.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'flashlight.on.fill'
                                                                                                                                                                                                                                                                                                                        | 'flashlight.slash'
                                                                                                                                                                                                                                                                                                                        | 'flashlight.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'flashlight.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'flask'
                                                                                                                                                                                                                                                                                                                        | 'flask.fill'
                                                                                                                                                                                                                                                                                                                        | 'fleuron'
                                                                                                                                                                                                                                                                                                                        | 'fleuron.fill'
                                                                                                                                                                                                                                                                                                                        | 'flip.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'flip.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'flipphone'
                                                                                                                                                                                                                                                                                                                        | 'florinsign'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.square'
                                                                                                                                                                                                                                                                                                                        | 'florinsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'flowchart'
                                                                                                                                                                                                                                                                                                                        | 'flowchart.fill'
                                                                                                                                                                                                                                                                                                                        | 'fluid.batteryblock'
                                                                                                                                                                                                                                                                                                                        | 'fluid.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'fluid.coolant'
                                                                                                                                                                                                                                                                                                                        | 'fluid.transmission'
                                                                                                                                                                                                                                                                                                                        | 'fn'
                                                                                                                                                                                                                                                                                                                        | 'folder'
                                                                                                                                                                                                                                                                                                                        | 'folder.and.person'
                                                                                                                                                                                                                                                                                                                        | 'folder.and.person.fill'
                                                                                                                                                                                                                                                                                                                        | 'folder.badge.gear'
                                                                                                                                                                                                                                                                                                                        | 'folder.badge.gearshape'
                                                                                                                                                                                                                                                                                                                        | 'folder.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'folder.badge.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'folder.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'folder.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'folder.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'folder.circle'
                                                                                                                                                                                                                                                                                                                        | 'folder.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'folder.fill'
                                                                                                                                                                                                                                                                                                                        | 'folder.fill.badge.gear'
                                                                                                                                                                                                                                                                                                                        | 'folder.fill.badge.gearshape'
                                                                                                                                                                                                                                                                                                                        | 'folder.fill.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'folder.fill.badge.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'folder.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'folder.fill.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'folder.fill.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'football'
                                                                                                                                                                                                                                                                                                                        | 'football.circle'
                                                                                                                                                                                                                                                                                                                        | 'football.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'football.fill'
                                                                                                                                                                                                                                                                                                                        | 'fork.knife'
                                                                                                                                                                                                                                                                                                                        | 'fork.knife.circle'
                                                                                                                                                                                                                                                                                                                        | 'fork.knife.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'formfitting.gamecontroller'
                                                                                                                                                                                                                                                                                                                        | 'formfitting.gamecontroller.fill'
                                                                                                                                                                                                                                                                                                                        | 'forward'
                                                                                                                                                                                                                                                                                                                        | 'forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'forward.end'
                                                                                                                                                                                                                                                                                                                        | 'forward.end.alt'
                                                                                                                                                                                                                                                                                                                        | 'forward.end.alt.fill'
                                                                                                                                                                                                                                                                                                                        | 'forward.end.circle'
                                                                                                                                                                                                                                                                                                                        | 'forward.end.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'forward.end.fill'
                                                                                                                                                                                                                                                                                                                        | 'forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'forward.frame'
                                                                                                                                                                                                                                                                                                                        | 'forward.frame.fill'
                                                                                                                                                                                                                                                                                                                        | 'fossil.shell'
                                                                                                                                                                                                                                                                                                                        | 'fossil.shell.fill'
                                                                                                                                                                                                                                                                                                                        | 'francsign'
                                                                                                                                                                                                                                                                                                                        | 'francsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'francsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'francsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'francsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'francsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'francsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'francsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'francsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'francsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'francsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'francsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'francsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'francsign.square'
                                                                                                                                                                                                                                                                                                                        | 'francsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'frying.pan'
                                                                                                                                                                                                                                                                                                                        | 'frying.pan.fill'
                                                                                                                                                                                                                                                                                                                        | 'fuel.filter.water'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.and.filter'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.arrowtriangle.left'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.arrowtriangle.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.arrowtriangle.right'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.arrowtriangle.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.circle'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.fill'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.nozzle.and.drop'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.slash'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.thermometer'
                                                                                                                                                                                                                                                                                                                        | 'fuelpump.thermometer.fill'
                                                                                                                                                                                                                                                                                                                        | 'function'
                                                                                                                                                                                                                                                                                                                        | 'function.ar'
                                                                                                                                                                                                                                                                                                                        | 'fx'
                                                                                                                                                                                                                                                                                                                        | 'g.circle'
                                                                                                                                                                                                                                                                                                                        | 'g.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'g.square'
                                                                                                                                                                                                                                                                                                                        | 'g.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'gamecontroller'
                                                                                                                                                                                                                                                                                                                        | 'gamecontroller.circle'
                                                                                                                                                                                                                                                                                                                        | 'gamecontroller.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'gamecontroller.fill'
                                                                                                                                                                                                                                                                                                                        | 'gauge'
                                                                                                                                                                                                                                                                                                                        | 'gauge.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'gauge.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'gauge.high'
                                                                                                                                                                                                                                                                                                                        | 'gauge.low'
                                                                                                                                                                                                                                                                                                                        | 'gauge.medium'
                                                                                                                                                                                                                                                                                                                        | 'gauge.medium.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'gauge.medium.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'gauge.open'
                                                                                                                                                                                                                                                                                                                        | 'gauge.open.righthalf.dotted.with.needle.and.arrow.trianglehead.backward'
                                                                                                                                                                                                                                                                                                                        | 'gauge.open.with.lines.needle.33percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.open.with.lines.needle.33percent.and.arrow.trianglehead.from.0percent.to.50percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.open.with.lines.needle.33percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'gauge.open.with.lines.needle.33percent.and.arrowtriangle.from.0percent.to.50percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.open.with.lines.needle.67percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'gauge.open.with.lines.needle.67percent.and.arrowtriangle.and.car'
                                                                                                                                                                                                                                                                                                                        | 'gauge.open.with.lines.needle.84percent.exclamation'
                                                                                                                                                                                                                                                                                                                        | 'gauge.range.33to100.dotted.with.needle'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.dots.needle.0percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.dots.needle.100percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.dots.needle.33percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.dots.needle.50percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.dots.needle.67percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.dots.needle.bottom.0percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.dots.needle.bottom.100percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.dots.needle.bottom.50percent'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.dots.needle.bottom.50percent.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.dots.needle.bottom.50percent.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.needle'
                                                                                                                                                                                                                                                                                                                        | 'gauge.with.needle.fill'
                                                                                                                                                                                                                                                                                                                        | 'gear'
                                                                                                                                                                                                                                                                                                                        | 'gear.badge'
                                                                                                                                                                                                                                                                                                                        | 'gear.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'gear.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'gear.badge.rtl'
                                                                                                                                                                                                                                                                                                                        | 'gear.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'gear.circle'
                                                                                                                                                                                                                                                                                                                        | 'gear.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'gearshape'
                                                                                                                                                                                                                                                                                                                        | 'gearshape.2'
                                                                                                                                                                                                                                                                                                                        | 'gearshape.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'gearshape.arrow.triangle.2.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'gearshape.arrow.trianglehead.2.clockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'gearshape.circle'
                                                                                                                                                                                                                                                                                                                        | 'gearshape.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'gearshape.fill'
                                                                                                                                                                                                                                                                                                                        | 'gearshift.layout.sixspeed'
                                                                                                                                                                                                                                                                                                                        | 'gift'
                                                                                                                                                                                                                                                                                                                        | 'gift.circle'
                                                                                                                                                                                                                                                                                                                        | 'gift.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'gift.fill'
                                                                                                                                                                                                                                                                                                                        | 'giftcard'
                                                                                                                                                                                                                                                                                                                        | 'giftcard.fill'
                                                                                                                                                                                                                                                                                                                        | 'globe'
                                                                                                                                                                                                                                                                                                                        | 'globe.americas'
                                                                                                                                                                                                                                                                                                                        | 'globe.americas.fill'
                                                                                                                                                                                                                                                                                                                        | 'globe.and.person'
                                                                                                                                                                                                                                                                                                                        | 'globe.asia.australia'
                                                                                                                                                                                                                                                                                                                        | 'globe.asia.australia.fill'
                                                                                                                                                                                                                                                                                                                        | 'globe.badge.chevron.backward'
                                                                                                                                                                                                                                                                                                                        | 'globe.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'globe.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'globe.central.south.asia'
                                                                                                                                                                                                                                                                                                                        | 'globe.central.south.asia.fill'
                                                                                                                                                                                                                                                                                                                        | 'globe.desk'
                                                                                                                                                                                                                                                                                                                        | 'globe.desk.fill'
                                                                                                                                                                                                                                                                                                                        | 'globe.europe.africa'
                                                                                                                                                                                                                                                                                                                        | 'globe.europe.africa.fill'
                                                                                                                                                                                                                                                                                                                        | 'globe.fill'
                                                                                                                                                                                                                                                                                                                        | 'glowplug'
                                                                                                                                                                                                                                                                                                                        | 'gobackward'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.10'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.10.ar'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.10.hi'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.15'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.15.ar'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.15.hi'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.30'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.30.ar'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.30.hi'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.45'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.45.ar'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.45.hi'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.5'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.5.ar'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.5.hi'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.60'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.60.ar'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.60.hi'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.75'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.75.ar'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.75.hi'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.90'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.90.ar'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.90.hi'
                                                                                                                                                                                                                                                                                                                        | 'gobackward.minus'
                                                                                                                                                                                                                                                                                                                        | 'goforward'
                                                                                                                                                                                                                                                                                                                        | 'goforward.10'
                                                                                                                                                                                                                                                                                                                        | 'goforward.10.ar'
                                                                                                                                                                                                                                                                                                                        | 'goforward.10.hi'
                                                                                                                                                                                                                                                                                                                        | 'goforward.15'
                                                                                                                                                                                                                                                                                                                        | 'goforward.15.ar'
                                                                                                                                                                                                                                                                                                                        | 'goforward.15.hi'
                                                                                                                                                                                                                                                                                                                        | 'goforward.30'
                                                                                                                                                                                                                                                                                                                        | 'goforward.30.ar'
                                                                                                                                                                                                                                                                                                                        | 'goforward.30.hi'
                                                                                                                                                                                                                                                                                                                        | 'goforward.45'
                                                                                                                                                                                                                                                                                                                        | 'goforward.45.ar'
                                                                                                                                                                                                                                                                                                                        | 'goforward.45.hi'
                                                                                                                                                                                                                                                                                                                        | 'goforward.5'
                                                                                                                                                                                                                                                                                                                        | 'goforward.5.ar'
                                                                                                                                                                                                                                                                                                                        | 'goforward.5.hi'
                                                                                                                                                                                                                                                                                                                        | 'goforward.60'
                                                                                                                                                                                                                                                                                                                        | 'goforward.60.ar'
                                                                                                                                                                                                                                                                                                                        | 'goforward.60.hi'
                                                                                                                                                                                                                                                                                                                        | 'goforward.75'
                                                                                                                                                                                                                                                                                                                        | 'goforward.75.ar'
                                                                                                                                                                                                                                                                                                                        | 'goforward.75.hi'
                                                                                                                                                                                                                                                                                                                        | 'goforward.90'
                                                                                                                                                                                                                                                                                                                        | 'goforward.90.ar'
                                                                                                                                                                                                                                                                                                                        | 'goforward.90.hi'
                                                                                                                                                                                                                                                                                                                        | 'goforward.plus'
                                                                                                                                                                                                                                                                                                                        | 'graduationcap'
                                                                                                                                                                                                                                                                                                                        | 'graduationcap.circle'
                                                                                                                                                                                                                                                                                                                        | 'graduationcap.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'graduationcap.fill'
                                                                                                                                                                                                                                                                                                                        | 'graph.2d'
                                                                                                                                                                                                                                                                                                                        | 'graph.3d'
                                                                                                                                                                                                                                                                                                                        | 'greaterthan'
                                                                                                                                                                                                                                                                                                                        | 'greaterthan.circle'
                                                                                                                                                                                                                                                                                                                        | 'greaterthan.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'greaterthan.square'
                                                                                                                                                                                                                                                                                                                        | 'greaterthan.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'greaterthanorequalto'
                                                                                                                                                                                                                                                                                                                        | 'greaterthanorequalto.circle'
                                                                                                                                                                                                                                                                                                                        | 'greaterthanorequalto.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'greaterthanorequalto.square'
                                                                                                                                                                                                                                                                                                                        | 'greaterthanorequalto.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'greetingcard'
                                                                                                                                                                                                                                                                                                                        | 'greetingcard.fill'
                                                                                                                                                                                                                                                                                                                        | 'grid'
                                                                                                                                                                                                                                                                                                                        | 'grid.circle'
                                                                                                                                                                                                                                                                                                                        | 'grid.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.circle'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.ring'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.square'
                                                                                                                                                                                                                                                                                                                        | 'guaranisign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'guidepoint.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'guidepoint.vertical'
                                                                                                                                                                                                                                                                                                                        | 'guidepoint.vertical.arrowtriangle.forward'
                                                                                                                                                                                                                                                                                                                        | 'guidepoint.vertical.numbers'
                                                                                                                                                                                                                                                                                                                        | 'guitars'
                                                                                                                                                                                                                                                                                                                        | 'guitars.fill'
                                                                                                                                                                                                                                                                                                                        | 'gym.bag'
                                                                                                                                                                                                                                                                                                                        | 'gym.bag.fill'
                                                                                                                                                                                                                                                                                                                        | 'gyroscope'
                                                                                                                                                                                                                                                                                                                        | 'h.circle'
                                                                                                                                                                                                                                                                                                                        | 'h.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'h.square'
                                                                                                                                                                                                                                                                                                                        | 'h.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'h.square.fill.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'h.square.on.square'
                                                                                                                                                                                                                                                                                                                        | 'h.square.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'hammer'
                                                                                                                                                                                                                                                                                                                        | 'hammer.circle'
                                                                                                                                                                                                                                                                                                                        | 'hammer.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hammer.fill'
                                                                                                                                                                                                                                                                                                                        | 'hammer.slash'
                                                                                                                                                                                                                                                                                                                        | 'hammer.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.app'
                                                                                                                                                                                                                                                                                                                        | 'hand.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.draw'
                                                                                                                                                                                                                                                                                                                        | 'hand.draw.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'hand.draw.badge.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.draw.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.palm.facing'
                                                                                                                                                                                                                                                                                                                        | 'hand.palm.facing.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.pinch'
                                                                                                                                                                                                                                                                                                                        | 'hand.pinch.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.down'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.left'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.right'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.up'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.up.braille'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.up.braille.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.up.braille.badge.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.up.braille.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.up.left'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.up.left.and.text'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.up.left.and.text.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.point.up.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.app'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.brakesignal.slash'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.circle'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.fingers.spread'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.fingers.spread.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.palm.facing'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.palm.facing.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.slash'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.square'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.square.on.square'
                                                                                                                                                                                                                                                                                                                        | 'hand.raised.square.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.rays'
                                                                                                                                                                                                                                                                                                                        | 'hand.rays.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.tap'
                                                                                                                                                                                                                                                                                                                        | 'hand.tap.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsdown'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsdown.circle'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsdown.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsdown.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsdown.filled.hand.thumbsup'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsdown.hand.thumbsup'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsdown.hand.thumbsup.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsdown.hand.thumbsup.filled'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsdown.slash'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsdown.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsup'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsup.circle'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsup.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsup.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsup.slash'
                                                                                                                                                                                                                                                                                                                        | 'hand.thumbsup.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'hand.wave'
                                                                                                                                                                                                                                                                                                                        | 'hand.wave.fill'
                                                                                                                                                                                                                                                                                                                        | 'handbag'
                                                                                                                                                                                                                                                                                                                        | 'handbag.circle'
                                                                                                                                                                                                                                                                                                                        | 'handbag.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'handbag.fill'
                                                                                                                                                                                                                                                                                                                        | 'handbag.sensor.tag.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'handbag.sensor.tag.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'hands.and.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'hands.and.sparkles.fill'
                                                                                                                                                                                                                                                                                                                        | 'hands.clap'
                                                                                                                                                                                                                                                                                                                        | 'hands.clap.fill'
                                                                                                                                                                                                                                                                                                                        | 'hands.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'hands.sparkles.fill'
                                                                                                                                                                                                                                                                                                                        | 'hanger'
                                                                                                                                                                                                                                                                                                                        | 'hare'
                                                                                                                                                                                                                                                                                                                        | 'hare.circle'
                                                                                                                                                                                                                                                                                                                        | 'hare.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hare.fill'
                                                                                                                                                                                                                                                                                                                        | 'hat.cap'
                                                                                                                                                                                                                                                                                                                        | 'hat.cap.fill'
                                                                                                                                                                                                                                                                                                                        | 'hat.widebrim'
                                                                                                                                                                                                                                                                                                                        | 'hat.widebrim.fill'
                                                                                                                                                                                                                                                                                                                        | 'hazardsign'
                                                                                                                                                                                                                                                                                                                        | 'hazardsign.fill'
                                                                                                                                                                                                                                                                                                                        | 'head.profile.arrow.forward.and.vision.pro'
                                                                                                                                                                                                                                                                                                                        | 'head.profile.arrow.forward.and.visionpro'
                                                                                                                                                                                                                                                                                                                        | 'head.profile.vision.pro.remove'
                                                                                                                                                                                                                                                                                                                        | 'headlight.daytime'
                                                                                                                                                                                                                                                                                                                        | 'headlight.daytime.fill'
                                                                                                                                                                                                                                                                                                                        | 'headlight.fog'
                                                                                                                                                                                                                                                                                                                        | 'headlight.fog.fill'
                                                                                                                                                                                                                                                                                                                        | 'headlight.high.beam'
                                                                                                                                                                                                                                                                                                                        | 'headlight.high.beam.fill'
                                                                                                                                                                                                                                                                                                                        | 'headlight.low.beam'
                                                                                                                                                                                                                                                                                                                        | 'headlight.low.beam.fill'
                                                                                                                                                                                                                                                                                                                        | 'headphones'
                                                                                                                                                                                                                                                                                                                        | 'headphones.circle'
                                                                                                                                                                                                                                                                                                                        | 'headphones.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'headphones.dots'
                                                                                                                                                                                                                                                                                                                        | 'headphones.over.ear'
                                                                                                                                                                                                                                                                                                                        | 'headphones.sensor.tag.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'headphones.sensor.tag.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'headphones.slash'
                                                                                                                                                                                                                                                                                                                        | 'headset'
                                                                                                                                                                                                                                                                                                                        | 'headset.circle'
                                                                                                                                                                                                                                                                                                                        | 'headset.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hearingaid.ear'
                                                                                                                                                                                                                                                                                                                        | 'hearingdevice.and.signal.meter'
                                                                                                                                                                                                                                                                                                                        | 'hearingdevice.and.signal.meter.fill'
                                                                                                                                                                                                                                                                                                                        | 'hearingdevice.ear'
                                                                                                                                                                                                                                                                                                                        | 'hearingdevice.ear.fill'
                                                                                                                                                                                                                                                                                                                        | 'heart'
                                                                                                                                                                                                                                                                                                                        | 'heart.badge.bolt'
                                                                                                                                                                                                                                                                                                                        | 'heart.badge.bolt.fill'
                                                                                                                                                                                                                                                                                                                        | 'heart.badge.bolt.slash'
                                                                                                                                                                                                                                                                                                                        | 'heart.badge.bolt.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'heart.circle'
                                                                                                                                                                                                                                                                                                                        | 'heart.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'heart.fill'
                                                                                                                                                                                                                                                                                                                        | 'heart.gauge.open'
                                                                                                                                                                                                                                                                                                                        | 'heart.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'heart.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'heart.slash'
                                                                                                                                                                                                                                                                                                                        | 'heart.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'heart.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'heart.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'heart.square'
                                                                                                                                                                                                                                                                                                                        | 'heart.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'heart.text.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'heart.text.clipboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'heart.text.square'
                                                                                                                                                                                                                                                                                                                        | 'heart.text.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'heat.element.windshield'
                                                                                                                                                                                                                                                                                                                        | 'heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'heat.waves.and.fan'
                                                                                                                                                                                                                                                                                                                        | 'heat.waves.circle'
                                                                                                                                                                                                                                                                                                                        | 'heat.waves.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'heat.waves.gauge.open'
                                                                                                                                                                                                                                                                                                                        | 'heater.vertical'
                                                                                                                                                                                                                                                                                                                        | 'heater.vertical.fill'
                                                                                                                                                                                                                                                                                                                        | 'helm'
                                                                                                                                                                                                                                                                                                                        | 'helmet'
                                                                                                                                                                                                                                                                                                                        | 'helmet.fill'
                                                                                                                                                                                                                                                                                                                        | 'hexagon'
                                                                                                                                                                                                                                                                                                                        | 'hexagon.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'hexagon.fill'
                                                                                                                                                                                                                                                                                                                        | 'hexagon.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'hexagon.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'hexagon.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'hifireceiver'
                                                                                                                                                                                                                                                                                                                        | 'hifireceiver.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.badge.checkmark.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.appletv'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.appletv.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.appletv.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.appletv.rtl'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.badge.checkmark.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.badge.checkmark.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepod.mini.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepodmini'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.and.homepodmini.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.arrow.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.badge.checkmark.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'hifispeaker.fill'
                                                                                                                                                                                                                                                                                                                        | 'highlighter'
                                                                                                                                                                                                                                                                                                                        | 'highlighter.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'hockey.puck'
                                                                                                                                                                                                                                                                                                                        | 'hockey.puck.circle'
                                                                                                                                                                                                                                                                                                                        | 'hockey.puck.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hockey.puck.fill'
                                                                                                                                                                                                                                                                                                                        | 'hold.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'homekit'
                                                                                                                                                                                                                                                                                                                        | 'homepod'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.badge.checkmark.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.appletv'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.appletv.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.appletv.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.appletv.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.badge.checkmark.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepod.mini.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepodmini'
                                                                                                                                                                                                                                                                                                                        | 'homepod.and.homepodmini.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'homepod.arrow.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'homepod.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.badge.checkmark.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'homepod.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'homepod.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'homepod.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.badge.checkmark.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.and.appletv'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.and.appletv.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.and.appletv.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.and.appletv.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.arrow.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.badge.checkmark.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepod.mini.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepodmini'
                                                                                                                                                                                                                                                                                                                        | 'homepodmini.2'
                                                                                                                                                                                                                                                                                                                        | 'homepodmini.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepodmini.and.appletv'
                                                                                                                                                                                                                                                                                                                        | 'homepodmini.and.appletv.fill'
                                                                                                                                                                                                                                                                                                                        | 'homepodmini.and.appletv.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepodmini.and.appletv.rtl'
                                                                                                                                                                                                                                                                                                                        | 'homepodmini.fill'
                                                                                                                                                                                                                                                                                                                        | 'horn'
                                                                                                                                                                                                                                                                                                                        | 'horn.blast'
                                                                                                                                                                                                                                                                                                                        | 'horn.blast.fill'
                                                                                                                                                                                                                                                                                                                        | 'horn.fill'
                                                                                                                                                                                                                                                                                                                        | 'hourglass'
                                                                                                                                                                                                                                                                                                                        | 'hourglass.and.lock'
                                                                                                                                                                                                                                                                                                                        | 'hourglass.badge.eye'
                                                                                                                                                                                                                                                                                                                        | 'hourglass.badge.lock'
                                                                                                                                                                                                                                                                                                                        | 'hourglass.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'hourglass.bottomhalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'hourglass.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'hourglass.circle'
                                                                                                                                                                                                                                                                                                                        | 'hourglass.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hourglass.tophalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'hourglass.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'house'
                                                                                                                                                                                                                                                                                                                        | 'house.and.flag'
                                                                                                                                                                                                                                                                                                                        | 'house.and.flag.circle'
                                                                                                                                                                                                                                                                                                                        | 'house.and.flag.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'house.and.flag.fill'
                                                                                                                                                                                                                                                                                                                        | 'house.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'house.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'house.badge.wifi'
                                                                                                                                                                                                                                                                                                                        | 'house.badge.wifi.fill'
                                                                                                                                                                                                                                                                                                                        | 'house.circle'
                                                                                                                                                                                                                                                                                                                        | 'house.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'house.fill'
                                                                                                                                                                                                                                                                                                                        | 'house.lodge'
                                                                                                                                                                                                                                                                                                                        | 'house.lodge.circle'
                                                                                                                                                                                                                                                                                                                        | 'house.lodge.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'house.lodge.fill'
                                                                                                                                                                                                                                                                                                                        | 'house.slash'
                                                                                                                                                                                                                                                                                                                        | 'house.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.circle'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.ring'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.square'
                                                                                                                                                                                                                                                                                                                        | 'hryvniasign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'humidifier'
                                                                                                                                                                                                                                                                                                                        | 'humidifier.and.droplets'
                                                                                                                                                                                                                                                                                                                        | 'humidifier.and.droplets.fill'
                                                                                                                                                                                                                                                                                                                        | 'humidifier.and.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'humidifier.and.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'humidifier.fill'
                                                                                                                                                                                                                                                                                                                        | 'humidity'
                                                                                                                                                                                                                                                                                                                        | 'humidity.fill'
                                                                                                                                                                                                                                                                                                                        | 'hurricane'
                                                                                                                                                                                                                                                                                                                        | 'hurricane.circle'
                                                                                                                                                                                                                                                                                                                        | 'hurricane.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hydrogen'
                                                                                                                                                                                                                                                                                                                        | 'hydrogen.circle'
                                                                                                                                                                                                                                                                                                                        | 'hydrogen.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'hydrogen.square'
                                                                                                                                                                                                                                                                                                                        | 'hydrogen.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'i.circle'
                                                                                                                                                                                                                                                                                                                        | 'i.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'i.square'
                                                                                                                                                                                                                                                                                                                        | 'i.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'icloud'
                                                                                                                                                                                                                                                                                                                        | 'icloud.and.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'icloud.and.arrow.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'icloud.and.arrow.up'
                                                                                                                                                                                                                                                                                                                        | 'icloud.and.arrow.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'icloud.circle'
                                                                                                                                                                                                                                                                                                                        | 'icloud.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'icloud.dashed'
                                                                                                                                                                                                                                                                                                                        | 'icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'icloud.slash'
                                                                                                                                                                                                                                                                                                                        | 'icloud.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'icloud.square'
                                                                                                                                                                                                                                                                                                                        | 'icloud.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'increase.indent'
                                                                                                                                                                                                                                                                                                                        | 'increase.quotelevel'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.circle'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.ring'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.square'
                                                                                                                                                                                                                                                                                                                        | 'indianrupeesign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'infinity'
                                                                                                                                                                                                                                                                                                                        | 'infinity.circle'
                                                                                                                                                                                                                                                                                                                        | 'infinity.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'info'
                                                                                                                                                                                                                                                                                                                        | 'info.app'
                                                                                                                                                                                                                                                                                                                        | 'info.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'info.bubble'
                                                                                                                                                                                                                                                                                                                        | 'info.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'info.bubble.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'info.bubble.rtl'
                                                                                                                                                                                                                                                                                                                        | 'info.circle'
                                                                                                                                                                                                                                                                                                                        | 'info.circle.badge'
                                                                                                                                                                                                                                                                                                                        | 'info.circle.badge.fill'
                                                                                                                                                                                                                                                                                                                        | 'info.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'info.circle.text.page'
                                                                                                                                                                                                                                                                                                                        | 'info.circle.text.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'info.circle.text.page.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'info.circle.text.page.rtl'
                                                                                                                                                                                                                                                                                                                        | 'info.square'
                                                                                                                                                                                                                                                                                                                        | 'info.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'info.triangle'
                                                                                                                                                                                                                                                                                                                        | 'info.triangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'info.windshield'
                                                                                                                                                                                                                                                                                                                        | 'inhaler'
                                                                                                                                                                                                                                                                                                                        | 'inhaler.fill'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.applewatch.case'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomhalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomhalf.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomhalf.tophalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomleading.bottomtrailing.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomleading.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomleading.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomleft.bottomright.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomleft.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomleft.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomright.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomright.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomthird.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomthird.square'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomtrailing.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bottomtrailing.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.bubble'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.capsule'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.capsule.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.center.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.center.rectangle.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.center.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.circle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.circle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.circle.slash'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.diamond'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leadinghalf.arrow.leading.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leadinghalf.arrowtriangle.backward.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leadinghalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leadinghalf.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leadinghalf.toptrailing.bottomtrailing.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leadinghalf.trailinghalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leadingthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leadingthird.rectangle.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leadingthird.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leadingthird.square'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.lefthalf.arrow.left.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.lefthalf.arrowtriangle.left.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.lefthalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.lefthalf.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.lefthalf.righthalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.lefthalf.topright.bottomright.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leftthird.middlethird.rightthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leftthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leftthird.rectangle.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leftthird.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.leftthird.square'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.oval'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.oval.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.pano'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.and.cursorarrow'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.and.person'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.and.person.filled'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.and.person.filled.circle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.and.person.filled.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.and.person.filled.slash'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.and.person.filled.slash.rtl'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.and.person.slash'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.and.person.slash.rtl'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.and.pointer.arrow'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.badge.record'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.righthalf.arrow.right.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.righthalf.arrowtriangle.right.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.righthalf.lefthalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.righthalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.righthalf.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rightthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rightthird.rectangle.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rightthird.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.rightthird.square'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.square'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.square.dashed'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.square.dashed.micro'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.tophalf.bottomhalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.tophalf.bottomleft.bottomright.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.tophalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.tophalf.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topleading.bottomleading.trailinghalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topleading.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topleading.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topleft.bottomleft.righthalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topleft.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topleft.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topleft.topright.bottomhalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topleft.topright.bottomleft.bottomright.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topright.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topright.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topthird.middlethird.bottomthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topthird.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.topthird.square'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.toptrailing.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.toptrailing.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.trailinghalf.arrow.trailing.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.trailinghalf.arrowtriangle.forward.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.trailinghalf.leadinghalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.trailinghalf.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.trailinghalf.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.trailingthird.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.trailingthird.rectangle.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.trailingthird.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.trailingthird.square'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.triangle'
                                                                                                                                                                                                                                                                                                                        | 'inset.filled.tv'
                                                                                                                                                                                                                                                                                                                        | 'inset.left.half.filled.square.dashed.micro'
                                                                                                                                                                                                                                                                                                                        | 'inset.left.half.square.dashed.micro'
                                                                                                                                                                                                                                                                                                                        | 'inset.square.dashed.micro'
                                                                                                                                                                                                                                                                                                                        | 'interface.window'
                                                                                                                                                                                                                                                                                                                        | 'interface.window.and.pointer.arrow'
                                                                                                                                                                                                                                                                                                                        | 'interface.window.and.pointer.arrow.rtl'
                                                                                                                                                                                                                                                                                                                        | 'interface.window.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'interface.window.dashed'
                                                                                                                                                                                                                                                                                                                        | 'interface.window.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'interface.window.on.rectangle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'interface.window.on.rectangle.dashed.rtl'
                                                                                                                                                                                                                                                                                                                        | 'interface.window.on.rectangle.rtl'
                                                                                                                                                                                                                                                                                                                        | 'interface.window.stack'
                                                                                                                                                                                                                                                                                                                        | 'internaldrive'
                                                                                                                                                                                                                                                                                                                        | 'internaldrive.fill'
                                                                                                                                                                                                                                                                                                                        | 'ipad'
                                                                                                                                                                                                                                                                                                                        | 'ipad.and.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'ipad.and.iphone'
                                                                                                                                                                                                                                                                                                                        | 'ipad.and.iphone.slash'
                                                                                                                                                                                                                                                                                                                        | 'ipad.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'ipad.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'ipad.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'ipad.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'ipad.case'
                                                                                                                                                                                                                                                                                                                        | 'ipad.case.and.iphone.case'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.crop.homebutton.circle'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.landscape'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.landscape.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.landscape.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.landscape.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.landscape.slash'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.sizes'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen1.slash'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2.landscape'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2.landscape.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2.landscape.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2.landscape.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2.landscape.slash'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2.sizes'
                                                                                                                                                                                                                                                                                                                        | 'ipad.gen2.slash'
                                                                                                                                                                                                                                                                                                                        | 'ipad.homebutton'
                                                                                                                                                                                                                                                                                                                        | 'ipad.homebutton.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'ipad.homebutton.landscape'
                                                                                                                                                                                                                                                                                                                        | 'ipad.homebutton.landscape.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'ipad.landscape'
                                                                                                                                                                                                                                                                                                                        | 'ipad.landscape.and.applewatch'
                                                                                                                                                                                                                                                                                                                        | 'ipad.landscape.and.iphone'
                                                                                                                                                                                                                                                                                                                        | 'ipad.landscape.and.iphone.slash'
                                                                                                                                                                                                                                                                                                                        | 'ipad.landscape.and.ipod'
                                                                                                                                                                                                                                                                                                                        | 'ipad.landscape.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'ipad.landscape.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'ipad.landscape.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'ipad.rear.camera'
                                                                                                                                                                                                                                                                                                                        | 'ipad.sizes'
                                                                                                                                                                                                                                                                                                                        | 'iphone'
                                                                                                                                                                                                                                                                                                                        | 'iphone.and.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'iphone.and.arrow.forward.inward'
                                                                                                                                                                                                                                                                                                                        | 'iphone.and.arrow.forward.outward'
                                                                                                                                                                                                                                                                                                                        | 'iphone.and.arrow.left.and.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'iphone.and.arrow.left.and.arrow.right.inward'
                                                                                                                                                                                                                                                                                                                        | 'iphone.and.arrow.right.inward'
                                                                                                                                                                                                                                                                                                                        | 'iphone.and.arrow.right.outward'
                                                                                                                                                                                                                                                                                                                        | 'iphone.and.ipod'
                                                                                                                                                                                                                                                                                                                        | 'iphone.and.vision.pro'
                                                                                                                                                                                                                                                                                                                        | 'iphone.app.switcher'
                                                                                                                                                                                                                                                                                                                        | 'iphone.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'iphone.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'iphone.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'iphone.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'iphone.case'
                                                                                                                                                                                                                                                                                                                        | 'iphone.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.crop.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.dock.motorized.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.and.arrow.left'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.crop.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.crop.homebutton.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.landscape'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.landscape.slash'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.motion'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.radiowaves.left.and.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.radiowaves.left.and.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.sizes'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.slash'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen1.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.and.arrow.left.and.arrow.right.inward'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.crop.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.landscape'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.landscape.slash'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.motion'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.radiowaves.left.and.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.radiowaves.left.and.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.sizes'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.slash'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen2.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.and.arrow.left.and.arrow.right.inward'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.crop.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.landscape'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.landscape.slash'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.motion'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.radiowaves.left.and.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.radiowaves.left.and.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.sizes'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.slash'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.gen3.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton.landscape'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton.radiowaves.left.and.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton.radiowaves.left.and.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton.slash'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.homebutton.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.landscape'
                                                                                                                                                                                                                                                                                                                        | 'iphone.motion'
                                                                                                                                                                                                                                                                                                                        | 'iphone.pattern.diagonalline'
                                                                                                                                                                                                                                                                                                                        | 'iphone.pattern.diagonalline.on.rectangle.portrait.dashed'
                                                                                                                                                                                                                                                                                                                        | 'iphone.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'iphone.radiowaves.left.and.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.radiowaves.left.and.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.rear.camera'
                                                                                                                                                                                                                                                                                                                        | 'iphone.sizes'
                                                                                                                                                                                                                                                                                                                        | 'iphone.slash'
                                                                                                                                                                                                                                                                                                                        | 'iphone.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'iphone.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'iphone.smartbatterycase.gen1'
                                                                                                                                                                                                                                                                                                                        | 'iphone.smartbatterycase.gen2'
                                                                                                                                                                                                                                                                                                                        | 'ipod'
                                                                                                                                                                                                                                                                                                                        | 'ipod.and.applewatch'
                                                                                                                                                                                                                                                                                                                        | 'ipod.and.vision.pro'
                                                                                                                                                                                                                                                                                                                        | 'ipod.shuffle.gen1'
                                                                                                                                                                                                                                                                                                                        | 'ipod.shuffle.gen2'
                                                                                                                                                                                                                                                                                                                        | 'ipod.shuffle.gen3'
                                                                                                                                                                                                                                                                                                                        | 'ipod.shuffle.gen4'
                                                                                                                                                                                                                                                                                                                        | 'ipod.touch'
                                                                                                                                                                                                                                                                                                                        | 'ipod.touch.landscape'
                                                                                                                                                                                                                                                                                                                        | 'ipod.touch.slash'
                                                                                                                                                                                                                                                                                                                        | 'ipodshuffle.gen1'
                                                                                                                                                                                                                                                                                                                        | 'ipodshuffle.gen2'
                                                                                                                                                                                                                                                                                                                        | 'ipodshuffle.gen3'
                                                                                                                                                                                                                                                                                                                        | 'ipodshuffle.gen4'
                                                                                                                                                                                                                                                                                                                        | 'ipodtouch'
                                                                                                                                                                                                                                                                                                                        | 'ipodtouch.landscape'
                                                                                                                                                                                                                                                                                                                        | 'ipodtouch.slash'
                                                                                                                                                                                                                                                                                                                        | 'italic'
                                                                                                                                                                                                                                                                                                                        | 'ivfluid.bag'
                                                                                                                                                                                                                                                                                                                        | 'ivfluid.bag.fill'
                                                                                                                                                                                                                                                                                                                        | 'j.circle'
                                                                                                                                                                                                                                                                                                                        | 'j.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'j.square'
                                                                                                                                                                                                                                                                                                                        | 'j.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'j.square.fill.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'j.square.on.square'
                                                                                                                                                                                                                                                                                                                        | 'j.square.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'jacket'
                                                                                                                                                                                                                                                                                                                        | 'jacket.circle'
                                                                                                                                                                                                                                                                                                                        | 'jacket.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'jacket.fill'
                                                                                                                                                                                                                                                                                                                        | 'jacket.sensor.tag.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'jacket.sensor.tag.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'k'
                                                                                                                                                                                                                                                                                                                        | 'k.circle'
                                                                                                                                                                                                                                                                                                                        | 'k.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'k.square'
                                                                                                                                                                                                                                                                                                                        | 'k.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'kashida.arabic'
                                                                                                                                                                                                                                                                                                                        | 'key'
                                                                                                                                                                                                                                                                                                                        | 'key.2.on.ring'
                                                                                                                                                                                                                                                                                                                        | 'key.2.on.ring.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.car.radiowaves.forward'
                                                                                                                                                                                                                                                                                                                        | 'key.car.radiowaves.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.car.radiowaves.forward.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'key.car.radiowaves.forward.rtl'
                                                                                                                                                                                                                                                                                                                        | 'key.car.side'
                                                                                                                                                                                                                                                                                                                        | 'key.car.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.card'
                                                                                                                                                                                                                                                                                                                        | 'key.card.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.circle'
                                                                                                                                                                                                                                                                                                                        | 'key.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.convertible.side'
                                                                                                                                                                                                                                                                                                                        | 'key.convertible.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'key.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.icloud'
                                                                                                                                                                                                                                                                                                                        | 'key.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.radiowaves.forward'
                                                                                                                                                                                                                                                                                                                        | 'key.radiowaves.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.radiowaves.forward.slash'
                                                                                                                                                                                                                                                                                                                        | 'key.radiowaves.forward.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.sensor.tag.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'key.sensor.tag.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.shield'
                                                                                                                                                                                                                                                                                                                        | 'key.shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.slash'
                                                                                                                                                                                                                                                                                                                        | 'key.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.suv.side'
                                                                                                                                                                                                                                                                                                                        | 'key.suv.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.truck.pickup.side'
                                                                                                                                                                                                                                                                                                                        | 'key.truck.pickup.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'key.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'keyboard'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.badge.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.badge.eye'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.badge.eye.fill'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.chevron.compact.down'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.chevron.compact.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.chevron.compact.left'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.chevron.compact.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.interface.window'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.macwindow'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.onehanded.left'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.onehanded.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.onehanded.right'
                                                                                                                                                                                                                                                                                                                        | 'keyboard.onehanded.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'kipsign'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.square'
                                                                                                                                                                                                                                                                                                                        | 'kipsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'kph'
                                                                                                                                                                                                                                                                                                                        | 'kph.circle'
                                                                                                                                                                                                                                                                                                                        | 'kph.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.button.roundedbottom.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'l.button.roundedbottom.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.circle'
                                                                                                                                                                                                                                                                                                                        | 'l.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.down'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.press.down'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.press.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.tilt.down'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.tilt.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.tilt.left'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.tilt.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.tilt.right'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.tilt.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.tilt.up'
                                                                                                                                                                                                                                                                                                                        | 'l.joystick.tilt.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.rectangle.roundedbottom'
                                                                                                                                                                                                                                                                                                                        | 'l.rectangle.roundedbottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'l.square'
                                                                                                                                                                                                                                                                                                                        | 'l.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'l1.button.roundedbottom.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'l1.button.roundedbottom.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'l1.circle'
                                                                                                                                                                                                                                                                                                                        | 'l1.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'l1.rectangle.roundedbottom'
                                                                                                                                                                                                                                                                                                                        | 'l1.rectangle.roundedbottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'l2.button.angledtop.vertical.left'
                                                                                                                                                                                                                                                                                                                        | 'l2.button.angledtop.vertical.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'l2.button.roundedtop.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'l2.button.roundedtop.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'l2.circle'
                                                                                                                                                                                                                                                                                                                        | 'l2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'l2.rectangle.roundedtop'
                                                                                                                                                                                                                                                                                                                        | 'l2.rectangle.roundedtop.fill'
                                                                                                                                                                                                                                                                                                                        | 'l3.button.angledbottom.horizontal.left'
                                                                                                                                                                                                                                                                                                                        | 'l3.button.angledbottom.horizontal.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'l4.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'l4.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'ladybug'
                                                                                                                                                                                                                                                                                                                        | 'ladybug.circle'
                                                                                                                                                                                                                                                                                                                        | 'ladybug.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'ladybug.fill'
                                                                                                                                                                                                                                                                                                                        | 'ladybug.slash'
                                                                                                                                                                                                                                                                                                                        | 'ladybug.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'ladybug.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'ladybug.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'lamp.ceiling'
                                                                                                                                                                                                                                                                                                                        | 'lamp.ceiling.fill'
                                                                                                                                                                                                                                                                                                                        | 'lamp.ceiling.inverse'
                                                                                                                                                                                                                                                                                                                        | 'lamp.desk'
                                                                                                                                                                                                                                                                                                                        | 'lamp.desk.fill'
                                                                                                                                                                                                                                                                                                                        | 'lamp.floor'
                                                                                                                                                                                                                                                                                                                        | 'lamp.floor.fill'
                                                                                                                                                                                                                                                                                                                        | 'lamp.table'
                                                                                                                                                                                                                                                                                                                        | 'lamp.table.fill'
                                                                                                                                                                                                                                                                                                                        | 'lane'
                                                                                                                                                                                                                                                                                                                        | 'lanyardcard'
                                                                                                                                                                                                                                                                                                                        | 'lanyardcard.fill'
                                                                                                                                                                                                                                                                                                                        | 'laptopcomputer'
                                                                                                                                                                                                                                                                                                                        | 'laptopcomputer.and.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'laptopcomputer.and.ipad'
                                                                                                                                                                                                                                                                                                                        | 'laptopcomputer.and.iphone'
                                                                                                                                                                                                                                                                                                                        | 'laptopcomputer.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'laptopcomputer.display.clean'
                                                                                                                                                                                                                                                                                                                        | 'laptopcomputer.slash'
                                                                                                                                                                                                                                                                                                                        | 'laptopcomputer.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'largecircle.fill.circle'
                                                                                                                                                                                                                                                                                                                        | 'larisign'
                                                                                                                                                                                                                                                                                                                        | 'larisign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'larisign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'larisign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'larisign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'larisign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'larisign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'larisign.circle'
                                                                                                                                                                                                                                                                                                                        | 'larisign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'larisign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'larisign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'larisign.ring'
                                                                                                                                                                                                                                                                                                                        | 'larisign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'larisign.square'
                                                                                                                                                                                                                                                                                                                        | 'larisign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'laser.burst'
                                                                                                                                                                                                                                                                                                                        | 'lasso'
                                                                                                                                                                                                                                                                                                                        | 'lasso.and.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'lasso.badge.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'lasso.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'latch.2.case'
                                                                                                                                                                                                                                                                                                                        | 'latch.2.case.fill'
                                                                                                                                                                                                                                                                                                                        | 'laurel.leading'
                                                                                                                                                                                                                                                                                                                        | 'laurel.leading.laurel.trailing'
                                                                                                                                                                                                                                                                                                                        | 'laurel.trailing'
                                                                                                                                                                                                                                                                                                                        | 'lb.button.roundedbottom.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'lb.button.roundedbottom.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'lb.circle'
                                                                                                                                                                                                                                                                                                                        | 'lb.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lb.rectangle.roundedbottom'
                                                                                                                                                                                                                                                                                                                        | 'lb.rectangle.roundedbottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'leaf'
                                                                                                                                                                                                                                                                                                                        | 'leaf.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'leaf.arrow.triangle.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'leaf.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'leaf.circle'
                                                                                                                                                                                                                                                                                                                        | 'leaf.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'leaf.fill'
                                                                                                                                                                                                                                                                                                                        | 'left'
                                                                                                                                                                                                                                                                                                                        | 'left.circle'
                                                                                                                                                                                                                                                                                                                        | 'left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lessthan'
                                                                                                                                                                                                                                                                                                                        | 'lessthan.circle'
                                                                                                                                                                                                                                                                                                                        | 'lessthan.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lessthan.square'
                                                                                                                                                                                                                                                                                                                        | 'lessthan.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'lessthanorequalto'
                                                                                                                                                                                                                                                                                                                        | 'lessthanorequalto.circle'
                                                                                                                                                                                                                                                                                                                        | 'lessthanorequalto.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lessthanorequalto.square'
                                                                                                                                                                                                                                                                                                                        | 'lessthanorequalto.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'level'
                                                                                                                                                                                                                                                                                                                        | 'level.fill'
                                                                                                                                                                                                                                                                                                                        | 'licenseplate'
                                                                                                                                                                                                                                                                                                                        | 'licenseplate.fill'
                                                                                                                                                                                                                                                                                                                        | 'lifepreserver'
                                                                                                                                                                                                                                                                                                                        | 'lifepreserver.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.beacon.max'
                                                                                                                                                                                                                                                                                                                        | 'light.beacon.max.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.beacon.min'
                                                                                                                                                                                                                                                                                                                        | 'light.beacon.min.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.cylindrical.ceiling'
                                                                                                                                                                                                                                                                                                                        | 'light.cylindrical.ceiling.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.cylindrical.ceiling.inverse'
                                                                                                                                                                                                                                                                                                                        | 'light.max'
                                                                                                                                                                                                                                                                                                                        | 'light.min'
                                                                                                                                                                                                                                                                                                                        | 'light.overhead.left'
                                                                                                                                                                                                                                                                                                                        | 'light.overhead.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.overhead.right'
                                                                                                                                                                                                                                                                                                                        | 'light.overhead.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.panel'
                                                                                                                                                                                                                                                                                                                        | 'light.panel.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.recessed'
                                                                                                                                                                                                                                                                                                                        | 'light.recessed.3'
                                                                                                                                                                                                                                                                                                                        | 'light.recessed.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.recessed.3.inverse'
                                                                                                                                                                                                                                                                                                                        | 'light.recessed.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.recessed.inverse'
                                                                                                                                                                                                                                                                                                                        | 'light.ribbon'
                                                                                                                                                                                                                                                                                                                        | 'light.ribbon.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.strip.2'
                                                                                                                                                                                                                                                                                                                        | 'light.strip.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'light.tube.rays'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.2'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.circle'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.led'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.led.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.led.wide'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.led.wide.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.max'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.max.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.min'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.min.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.min.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.min.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.slash'
                                                                                                                                                                                                                                                                                                                        | 'lightbulb.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightrail'
                                                                                                                                                                                                                                                                                                                        | 'lightrail.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightspectrum.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'lightswitch.off'
                                                                                                                                                                                                                                                                                                                        | 'lightswitch.off.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightswitch.off.square'
                                                                                                                                                                                                                                                                                                                        | 'lightswitch.off.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightswitch.on'
                                                                                                                                                                                                                                                                                                                        | 'lightswitch.on.fill'
                                                                                                                                                                                                                                                                                                                        | 'lightswitch.on.square'
                                                                                                                                                                                                                                                                                                                        | 'lightswitch.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'line.2.horizontal.decrease.circle'
                                                                                                                                                                                                                                                                                                                        | 'line.2.horizontal.decrease.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'line.3.crossed.swirl.circle'
                                                                                                                                                                                                                                                                                                                        | 'line.3.crossed.swirl.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'line.3.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'line.3.horizontal.button.angledtop.vertical.right'
                                                                                                                                                                                                                                                                                                                        | 'line.3.horizontal.button.angledtop.vertical.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'line.3.horizontal.circle'
                                                                                                                                                                                                                                                                                                                        | 'line.3.horizontal.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'line.3.horizontal.decrease'
                                                                                                                                                                                                                                                                                                                        | 'line.3.horizontal.decrease.circle'
                                                                                                                                                                                                                                                                                                                        | 'line.3.horizontal.decrease.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'line.diagonal'
                                                                                                                                                                                                                                                                                                                        | 'line.diagonal.arrow'
                                                                                                                                                                                                                                                                                                                        | 'line.diagonal.trianglehead.up.right'
                                                                                                                                                                                                                                                                                                                        | 'line.diagonal.trianglehead.up.right.left.down'
                                                                                                                                                                                                                                                                                                                        | 'line.horizontal.2.decrease.circle'
                                                                                                                                                                                                                                                                                                                        | 'line.horizontal.2.decrease.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'line.horizontal.3'
                                                                                                                                                                                                                                                                                                                        | 'line.horizontal.3.circle'
                                                                                                                                                                                                                                                                                                                        | 'line.horizontal.3.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'line.horizontal.3.decrease'
                                                                                                                                                                                                                                                                                                                        | 'line.horizontal.3.decrease.circle'
                                                                                                                                                                                                                                                                                                                        | 'line.horizontal.3.decrease.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'line.horizontal.star.fill.line.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'lines.measurement.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'lines.measurement.horizontal.aligned.bottom'
                                                                                                                                                                                                                                                                                                                        | 'lines.measurement.vertical'
                                                                                                                                                                                                                                                                                                                        | 'lineweight'
                                                                                                                                                                                                                                                                                                                        | 'link'
                                                                                                                                                                                                                                                                                                                        | 'link.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'link.circle'
                                                                                                                                                                                                                                                                                                                        | 'link.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'link.icloud'
                                                                                                                                                                                                                                                                                                                        | 'link.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'lirasign'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.circle'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.ring'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.square'
                                                                                                                                                                                                                                                                                                                        | 'lirasign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'list.and.film'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.below.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.circle'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.clipboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.indent'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'list.bullet.rectangle.portrait.fill'
                                                                                                                                                                                                                                                                                                                        | 'list.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'list.clipboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'list.dash'
                                                                                                                                                                                                                                                                                                                        | 'list.dash.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'list.dash.header.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'list.dash.header.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'list.number'
                                                                                                                                                                                                                                                                                                                        | 'list.number.ar'
                                                                                                                                                                                                                                                                                                                        | 'list.number.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'list.number.badge.ellipsis.hi'
                                                                                                                                                                                                                                                                                                                        | 'list.number.badge.ellipsis.rtl'
                                                                                                                                                                                                                                                                                                                        | 'list.number.hi'
                                                                                                                                                                                                                                                                                                                        | 'list.number.rtl'
                                                                                                                                                                                                                                                                                                                        | 'list.star'
                                                                                                                                                                                                                                                                                                                        | 'list.triangle'
                                                                                                                                                                                                                                                                                                                        | 'livephoto'
                                                                                                                                                                                                                                                                                                                        | 'livephoto.badge.a'
                                                                                                                                                                                                                                                                                                                        | 'livephoto.badge.automatic'
                                                                                                                                                                                                                                                                                                                        | 'livephoto.play'
                                                                                                                                                                                                                                                                                                                        | 'livephoto.slash'
                                                                                                                                                                                                                                                                                                                        | 'lizard'
                                                                                                                                                                                                                                                                                                                        | 'lizard.circle'
                                                                                                                                                                                                                                                                                                                        | 'lizard.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lizard.fill'
                                                                                                                                                                                                                                                                                                                        | 'lm.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'lm.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'location'
                                                                                                                                                                                                                                                                                                                        | 'location.app'
                                                                                                                                                                                                                                                                                                                        | 'location.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'location.circle'
                                                                                                                                                                                                                                                                                                                        | 'location.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'location.fill'
                                                                                                                                                                                                                                                                                                                        | 'location.fill.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'location.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'location.north'
                                                                                                                                                                                                                                                                                                                        | 'location.north.circle'
                                                                                                                                                                                                                                                                                                                        | 'location.north.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'location.north.fill'
                                                                                                                                                                                                                                                                                                                        | 'location.north.line'
                                                                                                                                                                                                                                                                                                                        | 'location.north.line.fill'
                                                                                                                                                                                                                                                                                                                        | 'location.slash'
                                                                                                                                                                                                                                                                                                                        | 'location.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'location.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'location.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'location.square'
                                                                                                                                                                                                                                                                                                                        | 'location.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'location.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'lock'
                                                                                                                                                                                                                                                                                                                        | 'lock.app.dashed'
                                                                                                                                                                                                                                                                                                                        | 'lock.applewatch'
                                                                                                                                                                                                                                                                                                                        | 'lock.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'lock.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'lock.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'lock.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.circle'
                                                                                                                                                                                                                                                                                                                        | 'lock.circle.dotted'
                                                                                                                                                                                                                                                                                                                        | 'lock.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.desktopcomputer'
                                                                                                                                                                                                                                                                                                                        | 'lock.display'
                                                                                                                                                                                                                                                                                                                        | 'lock.doc'
                                                                                                                                                                                                                                                                                                                        | 'lock.doc.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.document'
                                                                                                                                                                                                                                                                                                                        | 'lock.document.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.heart'
                                                                                                                                                                                                                                                                                                                        | 'lock.heart.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.icloud'
                                                                                                                                                                                                                                                                                                                        | 'lock.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.ipad'
                                                                                                                                                                                                                                                                                                                        | 'lock.iphone'
                                                                                                                                                                                                                                                                                                                        | 'lock.laptopcomputer'
                                                                                                                                                                                                                                                                                                                        | 'lock.open'
                                                                                                                                                                                                                                                                                                                        | 'lock.open.applewatch'
                                                                                                                                                                                                                                                                                                                        | 'lock.open.desktopcomputer'
                                                                                                                                                                                                                                                                                                                        | 'lock.open.display'
                                                                                                                                                                                                                                                                                                                        | 'lock.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.open.ipad'
                                                                                                                                                                                                                                                                                                                        | 'lock.open.iphone'
                                                                                                                                                                                                                                                                                                                        | 'lock.open.laptopcomputer'
                                                                                                                                                                                                                                                                                                                        | 'lock.open.rotation'
                                                                                                                                                                                                                                                                                                                        | 'lock.open.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'lock.open.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'lock.rectangle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'lock.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.rectangle.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'lock.rectangle.on.rectangle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'lock.rectangle.on.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.rectangle.stack'
                                                                                                                                                                                                                                                                                                                        | 'lock.rectangle.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.rotation'
                                                                                                                                                                                                                                                                                                                        | 'lock.rotation.open'
                                                                                                                                                                                                                                                                                                                        | 'lock.shield'
                                                                                                                                                                                                                                                                                                                        | 'lock.shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.slash'
                                                                                                                                                                                                                                                                                                                        | 'lock.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.square'
                                                                                                                                                                                                                                                                                                                        | 'lock.square.dashed'
                                                                                                                                                                                                                                                                                                                        | 'lock.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.square.stack'
                                                                                                                                                                                                                                                                                                                        | 'lock.square.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'lock.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'lock.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'logo.playstation'
                                                                                                                                                                                                                                                                                                                        | 'logo.xbox'
                                                                                                                                                                                                                                                                                                                        | 'long.text.page.and.pencil'
                                                                                                                                                                                                                                                                                                                        | 'long.text.page.and.pencil.fill'
                                                                                                                                                                                                                                                                                                                        | 'loupe'
                                                                                                                                                                                                                                                                                                                        | 'lsb.button.angledbottom.horizontal.left'
                                                                                                                                                                                                                                                                                                                        | 'lsb.button.angledbottom.horizontal.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'lt.button.roundedtop.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'lt.button.roundedtop.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'lt.circle'
                                                                                                                                                                                                                                                                                                                        | 'lt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'lt.rectangle.roundedtop'
                                                                                                                                                                                                                                                                                                                        | 'lt.rectangle.roundedtop.fill'
                                                                                                                                                                                                                                                                                                                        | 'lungs'
                                                                                                                                                                                                                                                                                                                        | 'lungs.fill'
                                                                                                                                                                                                                                                                                                                        | 'm.circle'
                                                                                                                                                                                                                                                                                                                        | 'm.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'm.square'
                                                                                                                                                                                                                                                                                                                        | 'm.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'm1.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'm1.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'm2.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'm2.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'm3.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'm3.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'm4.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'm4.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'macbook'
                                                                                                                                                                                                                                                                                                                        | 'macbook.and.applewatch'
                                                                                                                                                                                                                                                                                                                        | 'macbook.and.ipad'
                                                                                                                                                                                                                                                                                                                        | 'macbook.and.iphone'
                                                                                                                                                                                                                                                                                                                        | 'macbook.and.ipod'
                                                                                                                                                                                                                                                                                                                        | 'macbook.and.vision.pro'
                                                                                                                                                                                                                                                                                                                        | 'macbook.and.visionpro'
                                                                                                                                                                                                                                                                                                                        | 'macbook.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'macbook.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'macbook.badge.shield.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'macbook.gen1'
                                                                                                                                                                                                                                                                                                                        | 'macbook.gen1.sizes'
                                                                                                                                                                                                                                                                                                                        | 'macbook.gen2'
                                                                                                                                                                                                                                                                                                                        | 'macbook.gen2.sizes'
                                                                                                                                                                                                                                                                                                                        | 'macbook.sizes'
                                                                                                                                                                                                                                                                                                                        | 'macbook.slash'
                                                                                                                                                                                                                                                                                                                        | 'macbook.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'macmini'
                                                                                                                                                                                                                                                                                                                        | 'macmini.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'macmini.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'macmini.fill'
                                                                                                                                                                                                                                                                                                                        | 'macmini.gen2'
                                                                                                                                                                                                                                                                                                                        | 'macmini.gen2.fill'
                                                                                                                                                                                                                                                                                                                        | 'macmini.gen3'
                                                                                                                                                                                                                                                                                                                        | 'macmini.gen3.fill'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen1'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen1.fill'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen2'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen2.fill'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen3'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen3.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen3.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen3.badge.ckeckmark'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen3.badge.ckeckmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen3.fill'
                                                                                                                                                                                                                                                                                                                        | 'macpro.gen3.server'
                                                                                                                                                                                                                                                                                                                        | 'macstudio'
                                                                                                                                                                                                                                                                                                                        | 'macstudio.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'macstudio.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'macstudio.fill'
                                                                                                                                                                                                                                                                                                                        | 'macwindow'
                                                                                                                                                                                                                                                                                                                        | 'macwindow.and.cursorarrow'
                                                                                                                                                                                                                                                                                                                        | 'macwindow.and.cursorarrow.rtl'
                                                                                                                                                                                                                                                                                                                        | 'macwindow.and.pointer.arrow'
                                                                                                                                                                                                                                                                                                                        | 'macwindow.and.pointer.arrow.rtl'
                                                                                                                                                                                                                                                                                                                        | 'macwindow.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'macwindow.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'macwindow.on.rectangle.rtl'
                                                                                                                                                                                                                                                                                                                        | 'macwindow.stack'
                                                                                                                                                                                                                                                                                                                        | 'magazine'
                                                                                                                                                                                                                                                                                                                        | 'magazine.fill'
                                                                                                                                                                                                                                                                                                                        | 'magicmouse'
                                                                                                                                                                                                                                                                                                                        | 'magicmouse.fill'
                                                                                                                                                                                                                                                                                                                        | 'magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'magnifyingglass.circle'
                                                                                                                                                                                                                                                                                                                        | 'magnifyingglass.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'magsafe.batterypack'
                                                                                                                                                                                                                                                                                                                        | 'magsafe.batterypack.fill'
                                                                                                                                                                                                                                                                                                                        | 'mail'
                                                                                                                                                                                                                                                                                                                        | 'mail.and.text.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'mail.and.text.magnifyingglass.rtl'
                                                                                                                                                                                                                                                                                                                        | 'mail.fill'
                                                                                                                                                                                                                                                                                                                        | 'mail.stack'
                                                                                                                                                                                                                                                                                                                        | 'mail.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.square'
                                                                                                                                                                                                                                                                                                                        | 'malaysianringgitsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'manatsign'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.square'
                                                                                                                                                                                                                                                                                                                        | 'manatsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'map'
                                                                                                                                                                                                                                                                                                                        | 'map.circle'
                                                                                                                                                                                                                                                                                                                        | 'map.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'map.fill'
                                                                                                                                                                                                                                                                                                                        | 'mappin'
                                                                                                                                                                                                                                                                                                                        | 'mappin.and.ellipse'
                                                                                                                                                                                                                                                                                                                        | 'mappin.and.ellipse.circle'
                                                                                                                                                                                                                                                                                                                        | 'mappin.and.ellipse.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'mappin.circle'
                                                                                                                                                                                                                                                                                                                        | 'mappin.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'mappin.slash'
                                                                                                                                                                                                                                                                                                                        | 'mappin.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'mappin.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'mappin.square'
                                                                                                                                                                                                                                                                                                                        | 'mappin.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'matter.logo'
                                                                                                                                                                                                                                                                                                                        | 'mecca'
                                                                                                                                                                                                                                                                                                                        | 'medal'
                                                                                                                                                                                                                                                                                                                        | 'medal.fill'
                                                                                                                                                                                                                                                                                                                        | 'medal.star'
                                                                                                                                                                                                                                                                                                                        | 'medal.star.fill'
                                                                                                                                                                                                                                                                                                                        | 'mediastick'
                                                                                                                                                                                                                                                                                                                        | 'medical.thermometer'
                                                                                                                                                                                                                                                                                                                        | 'medical.thermometer.fill'
                                                                                                                                                                                                                                                                                                                        | 'megaphone'
                                                                                                                                                                                                                                                                                                                        | 'megaphone.fill'
                                                                                                                                                                                                                                                                                                                        | 'memories'
                                                                                                                                                                                                                                                                                                                        | 'memories.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'memories.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'memories.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'memories.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'memories.slash'
                                                                                                                                                                                                                                                                                                                        | 'memorychip'
                                                                                                                                                                                                                                                                                                                        | 'memorychip.fill'
                                                                                                                                                                                                                                                                                                                        | 'menubar.arrow.down.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'menubar.arrow.up.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'menubar.dock.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'menubar.dock.rectangle.badge.record'
                                                                                                                                                                                                                                                                                                                        | 'menubar.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'menucard'
                                                                                                                                                                                                                                                                                                                        | 'menucard.fill'
                                                                                                                                                                                                                                                                                                                        | 'message'
                                                                                                                                                                                                                                                                                                                        | 'message.and.waveform'
                                                                                                                                                                                                                                                                                                                        | 'message.and.waveform.fill'
                                                                                                                                                                                                                                                                                                                        | 'message.badge'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.circle'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.circle.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.circle.rtl'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.fill'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.filled.fill'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.filled.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.rtl'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.waveform'
                                                                                                                                                                                                                                                                                                                        | 'message.badge.waveform.fill'
                                                                                                                                                                                                                                                                                                                        | 'message.circle'
                                                                                                                                                                                                                                                                                                                        | 'message.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'message.fill'
                                                                                                                                                                                                                                                                                                                        | 'metronome'
                                                                                                                                                                                                                                                                                                                        | 'metronome.fill'
                                                                                                                                                                                                                                                                                                                        | 'mic'
                                                                                                                                                                                                                                                                                                                        | 'mic.and.signal.meter'
                                                                                                                                                                                                                                                                                                                        | 'mic.and.signal.meter.fill'
                                                                                                                                                                                                                                                                                                                        | 'mic.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'mic.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'mic.circle'
                                                                                                                                                                                                                                                                                                                        | 'mic.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'mic.fill'
                                                                                                                                                                                                                                                                                                                        | 'mic.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'mic.fill.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'mic.slash'
                                                                                                                                                                                                                                                                                                                        | 'mic.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'mic.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'mic.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'mic.square'
                                                                                                                                                                                                                                                                                                                        | 'mic.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'microbe'
                                                                                                                                                                                                                                                                                                                        | 'microbe.circle'
                                                                                                                                                                                                                                                                                                                        | 'microbe.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'microbe.fill'
                                                                                                                                                                                                                                                                                                                        | 'microphone'
                                                                                                                                                                                                                                                                                                                        | 'microphone.and.signal.meter'
                                                                                                                                                                                                                                                                                                                        | 'microphone.and.signal.meter.fill'
                                                                                                                                                                                                                                                                                                                        | 'microphone.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'microphone.badge.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'microphone.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'microphone.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'microphone.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'microphone.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'microphone.circle'
                                                                                                                                                                                                                                                                                                                        | 'microphone.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'microphone.dynamic.on.stand'
                                                                                                                                                                                                                                                                                                                        | 'microphone.dynamic.on.stand.circle'
                                                                                                                                                                                                                                                                                                                        | 'microphone.dynamic.on.stand.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'microphone.fill'
                                                                                                                                                                                                                                                                                                                        | 'microphone.slash'
                                                                                                                                                                                                                                                                                                                        | 'microphone.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'microphone.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'microphone.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'microphone.square'
                                                                                                                                                                                                                                                                                                                        | 'microphone.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'microwave'
                                                                                                                                                                                                                                                                                                                        | 'microwave.fill'
                                                                                                                                                                                                                                                                                                                        | 'millsign'
                                                                                                                                                                                                                                                                                                                        | 'millsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'millsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'millsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'millsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'millsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'millsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'millsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'millsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'millsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'millsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'millsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'millsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'millsign.square'
                                                                                                                                                                                                                                                                                                                        | 'millsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus'
                                                                                                                                                                                                                                                                                                                        | 'minus.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'minus.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | 'minus.circle'
                                                                                                                                                                                                                                                                                                                        | 'minus.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.diamond'
                                                                                                                                                                                                                                                                                                                        | 'minus.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.forwardslash.plus'
                                                                                                                                                                                                                                                                                                                        | 'minus.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.and.fluid.batteryblock'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.slash'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.stack'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.stack.arrowtriangle.left'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.stack.arrowtriangle.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.stack.arrowtriangle.right'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.stack.arrowtriangle.right.and.arrowtriangle.left'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.stack.arrowtriangle.right.and.arrowtriangle.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.stack.arrowtriangle.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.stack.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.stack.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.batteryblock.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.plus.lines.measurement.horizontal.aligned.bottom'
                                                                                                                                                                                                                                                                                                                        | 'minus.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'minus.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'minus.rectangle.portrait.fill'
                                                                                                                                                                                                                                                                                                                        | 'minus.slash.plus'
                                                                                                                                                                                                                                                                                                                        | 'minus.square'
                                                                                                                                                                                                                                                                                                                        | 'minus.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'mirror.side.left'
                                                                                                                                                                                                                                                                                                                        | 'mirror.side.left.and.arrow.turn.down.right'
                                                                                                                                                                                                                                                                                                                        | 'mirror.side.left.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'mirror.side.right'
                                                                                                                                                                                                                                                                                                                        | 'mirror.side.right.and.arrow.turn.down.left'
                                                                                                                                                                                                                                                                                                                        | 'mirror.side.right.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'moon'
                                                                                                                                                                                                                                                                                                                        | 'moon.circle'
                                                                                                                                                                                                                                                                                                                        | 'moon.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'moon.dust'
                                                                                                                                                                                                                                                                                                                        | 'moon.dust.circle'
                                                                                                                                                                                                                                                                                                                        | 'moon.dust.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'moon.dust.fill'
                                                                                                                                                                                                                                                                                                                        | 'moon.fill'
                                                                                                                                                                                                                                                                                                                        | 'moon.haze'
                                                                                                                                                                                                                                                                                                                        | 'moon.haze.circle'
                                                                                                                                                                                                                                                                                                                        | 'moon.haze.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'moon.haze.fill'
                                                                                                                                                                                                                                                                                                                        | 'moon.road.lanes'
                                                                                                                                                                                                                                                                                                                        | 'moon.stars'
                                                                                                                                                                                                                                                                                                                        | 'moon.stars.circle'
                                                                                                                                                                                                                                                                                                                        | 'moon.stars.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'moon.stars.fill'
                                                                                                                                                                                                                                                                                                                        | 'moon.zzz'
                                                                                                                                                                                                                                                                                                                        | 'moon.zzz.fill'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.first.quarter'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.first.quarter.inverse'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.full.moon'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.full.moon.inverse'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.last.quarter'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.last.quarter.inverse'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.new.moon'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.new.moon.inverse'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.waning.crescent'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.waning.crescent.inverse'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.waning.gibbous'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.waning.gibbous.inverse'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.waxing.crescent'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.waxing.crescent.inverse'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.waxing.gibbous'
                                                                                                                                                                                                                                                                                                                        | 'moonphase.waxing.gibbous.inverse'
                                                                                                                                                                                                                                                                                                                        | 'moonrise'
                                                                                                                                                                                                                                                                                                                        | 'moonrise.circle'
                                                                                                                                                                                                                                                                                                                        | 'moonrise.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'moonrise.fill'
                                                                                                                                                                                                                                                                                                                        | 'moonset'
                                                                                                                                                                                                                                                                                                                        | 'moonset.circle'
                                                                                                                                                                                                                                                                                                                        | 'moonset.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'moonset.fill'
                                                                                                                                                                                                                                                                                                                        | 'moped'
                                                                                                                                                                                                                                                                                                                        | 'moped.fill'
                                                                                                                                                                                                                                                                                                                        | 'mosaic'
                                                                                                                                                                                                                                                                                                                        | 'mosaic.fill'
                                                                                                                                                                                                                                                                                                                        | 'motor.electric.vehicle'
                                                                                                                                                                                                                                                                                                                        | 'motorcycle'
                                                                                                                                                                                                                                                                                                                        | 'motorcycle.fill'
                                                                                                                                                                                                                                                                                                                        | 'mount'
                                                                                                                                                                                                                                                                                                                        | 'mount.fill'
                                                                                                                                                                                                                                                                                                                        | 'mountain.2'
                                                                                                                                                                                                                                                                                                                        | 'mountain.2.circle'
                                                                                                                                                                                                                                                                                                                        | 'mountain.2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'mountain.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'mouth'
                                                                                                                                                                                                                                                                                                                        | 'mouth.fill'
                                                                                                                                                                                                                                                                                                                        | 'move.3d'
                                                                                                                                                                                                                                                                                                                        | 'movieclapper'
                                                                                                                                                                                                                                                                                                                        | 'movieclapper.fill'
                                                                                                                                                                                                                                                                                                                        | 'mph'
                                                                                                                                                                                                                                                                                                                        | 'mph.circle'
                                                                                                                                                                                                                                                                                                                        | 'mph.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'mug'
                                                                                                                                                                                                                                                                                                                        | 'mug.fill'
                                                                                                                                                                                                                                                                                                                        | 'multiply'
                                                                                                                                                                                                                                                                                                                        | 'multiply.circle'
                                                                                                                                                                                                                                                                                                                        | 'multiply.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'multiply.square'
                                                                                                                                                                                                                                                                                                                        | 'multiply.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'music.house'
                                                                                                                                                                                                                                                                                                                        | 'music.house.fill'
                                                                                                                                                                                                                                                                                                                        | 'music.mic'
                                                                                                                                                                                                                                                                                                                        | 'music.mic.circle'
                                                                                                                                                                                                                                                                                                                        | 'music.mic.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'music.microphone'
                                                                                                                                                                                                                                                                                                                        | 'music.microphone.circle'
                                                                                                                                                                                                                                                                                                                        | 'music.microphone.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'music.note'
                                                                                                                                                                                                                                                                                                                        | 'music.note.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'music.note.house'
                                                                                                                                                                                                                                                                                                                        | 'music.note.house.fill'
                                                                                                                                                                                                                                                                                                                        | 'music.note.list'
                                                                                                                                                                                                                                                                                                                        | 'music.note.slash'
                                                                                                                                                                                                                                                                                                                        | 'music.note.square.stack'
                                                                                                                                                                                                                                                                                                                        | 'music.note.square.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'music.note.tv'
                                                                                                                                                                                                                                                                                                                        | 'music.note.tv.fill'
                                                                                                                                                                                                                                                                                                                        | 'music.pages'
                                                                                                                                                                                                                                                                                                                        | 'music.pages.fill'
                                                                                                                                                                                                                                                                                                                        | 'music.quarternote.3'
                                                                                                                                                                                                                                                                                                                        | 'mustache'
                                                                                                                                                                                                                                                                                                                        | 'mustache.fill'
                                                                                                                                                                                                                                                                                                                        | 'n.circle'
                                                                                                                                                                                                                                                                                                                        | 'n.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'n.square'
                                                                                                                                                                                                                                                                                                                        | 'n.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'nairasign'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.circle'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.ring'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.square'
                                                                                                                                                                                                                                                                                                                        | 'nairasign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'network'
                                                                                                                                                                                                                                                                                                                        | 'network.badge.shield.half.filled'
                                                                                                                                                                                                                                                                                                                        | 'network.slash'
                                                                                                                                                                                                                                                                                                                        | 'newspaper'
                                                                                                                                                                                                                                                                                                                        | 'newspaper.circle'
                                                                                                                                                                                                                                                                                                                        | 'newspaper.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'newspaper.fill'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.circle'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.ring'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.square'
                                                                                                                                                                                                                                                                                                                        | 'norwegiankronesign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'nose'
                                                                                                                                                                                                                                                                                                                        | 'nose.fill'
                                                                                                                                                                                                                                                                                                                        | 'nosign'
                                                                                                                                                                                                                                                                                                                        | 'nosign.app'
                                                                                                                                                                                                                                                                                                                        | 'nosign.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'nosign.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'note'
                                                                                                                                                                                                                                                                                                                        | 'note.text'
                                                                                                                                                                                                                                                                                                                        | 'note.text.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'notequal'
                                                                                                                                                                                                                                                                                                                        | 'notequal.circle'
                                                                                                                                                                                                                                                                                                                        | 'notequal.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'notequal.square'
                                                                                                                                                                                                                                                                                                                        | 'notequal.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'number'
                                                                                                                                                                                                                                                                                                                        | 'number.circle'
                                                                                                                                                                                                                                                                                                                        | 'number.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'number.sign'
                                                                                                                                                                                                                                                                                                                        | 'number.sign.circle'
                                                                                                                                                                                                                                                                                                                        | 'number.sign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'number.sign.square'
                                                                                                                                                                                                                                                                                                                        | 'number.sign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'number.square'
                                                                                                                                                                                                                                                                                                                        | 'number.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'numbers'
                                                                                                                                                                                                                                                                                                                        | 'numbers.ar'
                                                                                                                                                                                                                                                                                                                        | 'numbers.bn'
                                                                                                                                                                                                                                                                                                                        | 'numbers.gu'
                                                                                                                                                                                                                                                                                                                        | 'numbers.hi'
                                                                                                                                                                                                                                                                                                                        | 'numbers.km'
                                                                                                                                                                                                                                                                                                                        | 'numbers.kn'
                                                                                                                                                                                                                                                                                                                        | 'numbers.ml'
                                                                                                                                                                                                                                                                                                                        | 'numbers.mni'
                                                                                                                                                                                                                                                                                                                        | 'numbers.mr'
                                                                                                                                                                                                                                                                                                                        | 'numbers.my'
                                                                                                                                                                                                                                                                                                                        | 'numbers.or'
                                                                                                                                                                                                                                                                                                                        | 'numbers.pa'
                                                                                                                                                                                                                                                                                                                        | 'numbers.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'numbers.rectangle.ar'
                                                                                                                                                                                                                                                                                                                        | 'numbers.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'numbers.rectangle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'numbers.rectangle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | 'numbers.rectangle.hi'
                                                                                                                                                                                                                                                                                                                        | 'numbers.sat'
                                                                                                                                                                                                                                                                                                                        | 'numbers.te'
                                                                                                                                                                                                                                                                                                                        | 'numbersign'
                                                                                                                                                                                                                                                                                                                        | 'numero.sign'
                                                                                                                                                                                                                                                                                                                        | 'o.circle'
                                                                                                                                                                                                                                                                                                                        | 'o.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'o.square'
                                                                                                                                                                                                                                                                                                                        | 'o.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'oar.2.crossed'
                                                                                                                                                                                                                                                                                                                        | 'oar.2.crossed.circle'
                                                                                                                                                                                                                                                                                                                        | 'oar.2.crossed.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'octagon'
                                                                                                                                                                                                                                                                                                                        | 'octagon.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'octagon.fill'
                                                                                                                                                                                                                                                                                                                        | 'octagon.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'octagon.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'octagon.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'oilcan'
                                                                                                                                                                                                                                                                                                                        | 'oilcan.and.thermometer'
                                                                                                                                                                                                                                                                                                                        | 'oilcan.and.thermometer.fill'
                                                                                                                                                                                                                                                                                                                        | 'oilcan.fill'
                                                                                                                                                                                                                                                                                                                        | 'opticaldisc'
                                                                                                                                                                                                                                                                                                                        | 'opticaldisc.fill'
                                                                                                                                                                                                                                                                                                                        | 'opticaldiscdrive'
                                                                                                                                                                                                                                                                                                                        | 'opticaldiscdrive.fill'
                                                                                                                                                                                                                                                                                                                        | 'opticid'
                                                                                                                                                                                                                                                                                                                        | 'opticid.fill'
                                                                                                                                                                                                                                                                                                                        | 'option'
                                                                                                                                                                                                                                                                                                                        | 'oval'
                                                                                                                                                                                                                                                                                                                        | 'oval.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'oval.fill'
                                                                                                                                                                                                                                                                                                                        | 'oval.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'oval.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'oval.portrait'
                                                                                                                                                                                                                                                                                                                        | 'oval.portrait.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'oval.portrait.fill'
                                                                                                                                                                                                                                                                                                                        | 'oval.portrait.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'oval.portrait.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'oval.portrait.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'oval.portrait.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'oval.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'oval.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'oven'
                                                                                                                                                                                                                                                                                                                        | 'oven.fill'
                                                                                                                                                                                                                                                                                                                        | 'p.circle'
                                                                                                                                                                                                                                                                                                                        | 'p.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'p.square'
                                                                                                                                                                                                                                                                                                                        | 'p.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'p1.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'p1.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'p2.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'p2.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'p3.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'p3.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'p4.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'p4.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'pad.header'
                                                                                                                                                                                                                                                                                                                        | 'paddleshifter.left'
                                                                                                                                                                                                                                                                                                                        | 'paddleshifter.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'paddleshifter.right'
                                                                                                                                                                                                                                                                                                                        | 'paddleshifter.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'paint.bucket.classic'
                                                                                                                                                                                                                                                                                                                        | 'paintbrush'
                                                                                                                                                                                                                                                                                                                        | 'paintbrush.fill'
                                                                                                                                                                                                                                                                                                                        | 'paintbrush.pointed'
                                                                                                                                                                                                                                                                                                                        | 'paintbrush.pointed.fill'
                                                                                                                                                                                                                                                                                                                        | 'paintbrush.slash'
                                                                                                                                                                                                                                                                                                                        | 'paintbrush.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'paintpalette'
                                                                                                                                                                                                                                                                                                                        | 'paintpalette.fill'
                                                                                                                                                                                                                                                                                                                        | 'pano'
                                                                                                                                                                                                                                                                                                                        | 'pano.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'pano.badge.play.fill'
                                                                                                                                                                                                                                                                                                                        | 'pano.fill'
                                                                                                                                                                                                                                                                                                                        | 'paperclip'
                                                                                                                                                                                                                                                                                                                        | 'paperclip.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'paperclip.circle'
                                                                                                                                                                                                                                                                                                                        | 'paperclip.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'paperplane'
                                                                                                                                                                                                                                                                                                                        | 'paperplane.circle'
                                                                                                                                                                                                                                                                                                                        | 'paperplane.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'paperplane.fill'
                                                                                                                                                                                                                                                                                                                        | 'paragraph'
                                                                                                                                                                                                                                                                                                                        | 'paragraphsign'
                                                                                                                                                                                                                                                                                                                        | 'parentheses'
                                                                                                                                                                                                                                                                                                                        | 'parkinglight'
                                                                                                                                                                                                                                                                                                                        | 'parkinglight.fill'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.brakesignal.slash'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.radiowaves.down.right.off'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.radiowaves.left.and.right.slash'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.radiowaves.right.and.safetycone'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.square'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'parkingsign.steeringwheel'
                                                                                                                                                                                                                                                                                                                        | 'party.popper'
                                                                                                                                                                                                                                                                                                                        | 'party.popper.fill'
                                                                                                                                                                                                                                                                                                                        | 'pause'
                                                                                                                                                                                                                                                                                                                        | 'pause.circle'
                                                                                                                                                                                                                                                                                                                        | 'pause.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pause.fill'
                                                                                                                                                                                                                                                                                                                        | 'pause.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'pause.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pawprint'
                                                                                                                                                                                                                                                                                                                        | 'pawprint.circle'
                                                                                                                                                                                                                                                                                                                        | 'pawprint.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pawprint.fill'
                                                                                                                                                                                                                                                                                                                        | 'pc'
                                                                                                                                                                                                                                                                                                                        | 'peacesign'
                                                                                                                                                                                                                                                                                                                        | 'pedal.accelerator'
                                                                                                                                                                                                                                                                                                                        | 'pedal.accelerator.fill'
                                                                                                                                                                                                                                                                                                                        | 'pedal.brake'
                                                                                                                                                                                                                                                                                                                        | 'pedal.brake.fill'
                                                                                                                                                                                                                                                                                                                        | 'pedal.clutch'
                                                                                                                                                                                                                                                                                                                        | 'pedal.clutch.fill'
                                                                                                                                                                                                                                                                                                                        | 'pedestrian.gate.closed'
                                                                                                                                                                                                                                                                                                                        | 'pedestrian.gate.closed.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'pedestrian.gate.open'
                                                                                                                                                                                                                                                                                                                        | 'pedestrian.gate.open.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'pencil'
                                                                                                                                                                                                                                                                                                                        | 'pencil.and.ellipsis.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'pencil.and.list.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'pencil.and.list.clipboard.rtl'
                                                                                                                                                                                                                                                                                                                        | 'pencil.and.outline'
                                                                                                                                                                                                                                                                                                                        | 'pencil.and.ruler'
                                                                                                                                                                                                                                                                                                                        | 'pencil.and.ruler.fill'
                                                                                                                                                                                                                                                                                                                        | 'pencil.and.scribble'
                                                                                                                                                                                                                                                                                                                        | 'pencil.circle'
                                                                                                                                                                                                                                                                                                                        | 'pencil.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pencil.line'
                                                                                                                                                                                                                                                                                                                        | 'pencil.slash'
                                                                                                                                                                                                                                                                                                                        | 'pencil.tip'
                                                                                                                                                                                                                                                                                                                        | 'pencil.tip.crop.circle'
                                                                                                                                                                                                                                                                                                                        | 'pencil.tip.crop.circle.badge.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'pencil.tip.crop.circle.badge.arrow.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'pencil.tip.crop.circle.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'pencil.tip.crop.circle.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'pencil.tip.crop.circle.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'pencil.tip.crop.circle.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'pencil.tip.crop.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pentagon'
                                                                                                                                                                                                                                                                                                                        | 'pentagon.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'pentagon.fill'
                                                                                                                                                                                                                                                                                                                        | 'pentagon.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'pentagon.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'pentagon.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'percent'
                                                                                                                                                                                                                                                                                                                        | 'percent.ar'
                                                                                                                                                                                                                                                                                                                        | 'person'
                                                                                                                                                                                                                                                                                                                        | 'person.2'
                                                                                                                                                                                                                                                                                                                        | 'person.2.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | 'person.2.badge'
                                                                                                                                                                                                                                                                                                                        | 'person.2.badge.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.badge.gearshape'
                                                                                                                                                                                                                                                                                                                        | 'person.2.badge.gearshape.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.badge.key'
                                                                                                                                                                                                                                                                                                                        | 'person.2.badge.key.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'person.2.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'person.2.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.circle'
                                                                                                                                                                                                                                                                                                                        | 'person.2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.crop.square.stack'
                                                                                                                                                                                                                                                                                                                        | 'person.2.crop.square.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.gobackward'
                                                                                                                                                                                                                                                                                                                        | 'person.2.shield'
                                                                                                                                                                                                                                                                                                                        | 'person.2.shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.slash'
                                                                                                                                                                                                                                                                                                                        | 'person.2.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.square.stack'
                                                                                                                                                                                                                                                                                                                        | 'person.2.square.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.2.wave.2'
                                                                                                                                                                                                                                                                                                                        | 'person.2.wave.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.3'
                                                                                                                                                                                                                                                                                                                        | 'person.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.3.sequence'
                                                                                                                                                                                                                                                                                                                        | 'person.3.sequence.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.and.arrow.left.and.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'person.and.arrow.left.and.arrow.right.outward'
                                                                                                                                                                                                                                                                                                                        | 'person.and.background.dotted'
                                                                                                                                                                                                                                                                                                                        | 'person.and.background.striped.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.checkmark.seal'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.checkmark.seal.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.creditcard'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.creditcard.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.gearshape'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.gearshape.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.key'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.key.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.location'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.location.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.shield.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.shield.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.shield.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'person.badge.shield.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.bubble'
                                                                                                                                                                                                                                                                                                                        | 'person.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'person.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.bust'
                                                                                                                                                                                                                                                                                                                        | 'person.bust.circle'
                                                                                                                                                                                                                                                                                                                        | 'person.bust.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.bust.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.checkmark.and.xmark'
                                                                                                                                                                                                                                                                                                                        | 'person.checkmark.and.xmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'person.circle'
                                                                                                                                                                                                                                                                                                                        | 'person.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.artframe'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.badge.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.badge.magnifyingglass.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.exclam'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.magnifyingglass.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.moon'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.moon.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.questionmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.questionmark.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.dashed.circle'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.dashed.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.fill.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.fill.badge.exclam'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.fill.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.fill.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.fill.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.fill.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.circle.fill.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.rectangle.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.rectangle.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.rectangle.stack'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.rectangle.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square.badge.camera'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square.badge.camera.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square.badge.video'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square.badge.video.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square.fill.and.at.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square.filled.and.at.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square.filled.and.at.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square.on.square.angled'
                                                                                                                                                                                                                                                                                                                        | 'person.crop.square.on.square.angled.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.and.arrow.left.and.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.and.arrow.left.and.arrow.right.outward'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.checkmark.and.xmark'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.checkmark.and.xmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.questionmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.turn.down'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.turn.left'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.turn.right'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.xmark'
                                                                                                                                                                                                                                                                                                                        | 'person.fill.xmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'person.icloud'
                                                                                                                                                                                                                                                                                                                        | 'person.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.line.dotted.person'
                                                                                                                                                                                                                                                                                                                        | 'person.line.dotted.person.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.number.sign.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'person.number.sign.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.slash'
                                                                                                                                                                                                                                                                                                                        | 'person.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.spatialaudio.3d.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.spatialaudio.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.spatialaudio.stereo.3d.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.spatialaudio.stereo.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.text.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'person.text.rectangle.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'person.text.rectangle.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.text.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.text.rectangle.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'person.text.rectangle.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.wave.2'
                                                                                                                                                                                                                                                                                                                        | 'person.wave.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'person.wave.2.inward'
                                                                                                                                                                                                                                                                                                                        | 'person.wave.2.inward.fill'
                                                                                                                                                                                                                                                                                                                        | 'personalhotspot'
                                                                                                                                                                                                                                                                                                                        | 'personalhotspot.circle'
                                                                                                                                                                                                                                                                                                                        | 'personalhotspot.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'personalhotspot.slash'
                                                                                                                                                                                                                                                                                                                        | 'perspective'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.circle'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.ring'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.square'
                                                                                                                                                                                                                                                                                                                        | 'peruviansolessign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.circle'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.ring'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.square'
                                                                                                                                                                                                                                                                                                                        | 'pesetasign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'pesosign'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.circle'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.ring'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.square'
                                                                                                                                                                                                                                                                                                                        | 'pesosign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'pet.carrier'
                                                                                                                                                                                                                                                                                                                        | 'pet.carrier.circle'
                                                                                                                                                                                                                                                                                                                        | 'pet.carrier.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pet.carrier.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone'
                                                                                                                                                                                                                                                                                                                        | 'phone.and.waveform'
                                                                                                                                                                                                                                                                                                                        | 'phone.and.waveform.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.arrow.down.left'
                                                                                                                                                                                                                                                                                                                        | 'phone.arrow.down.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'phone.arrow.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.arrow.up.right'
                                                                                                                                                                                                                                                                                                                        | 'phone.arrow.up.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'phone.arrow.up.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.arrow.up.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'phone.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'phone.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'phone.badge.waveform'
                                                                                                                                                                                                                                                                                                                        | 'phone.badge.waveform.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.bubble'
                                                                                                                                                                                                                                                                                                                        | 'phone.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.bubble.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'phone.bubble.left'
                                                                                                                                                                                                                                                                                                                        | 'phone.bubble.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.bubble.rtl'
                                                                                                                                                                                                                                                                                                                        | 'phone.circle'
                                                                                                                                                                                                                                                                                                                        | 'phone.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.connection'
                                                                                                                                                                                                                                                                                                                        | 'phone.connection.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.down'
                                                                                                                                                                                                                                                                                                                        | 'phone.down.circle'
                                                                                                                                                                                                                                                                                                                        | 'phone.down.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.down.waves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'phone.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.fill.arrow.down.left'
                                                                                                                                                                                                                                                                                                                        | 'phone.fill.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'phone.fill.arrow.up.right'
                                                                                                                                                                                                                                                                                                                        | 'phone.fill.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'phone.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'phone.fill.connection'
                                                                                                                                                                                                                                                                                                                        | 'phone.pause'
                                                                                                                                                                                                                                                                                                                        | 'phone.pause.circle'
                                                                                                                                                                                                                                                                                                                        | 'phone.pause.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'phone.pause.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo'
                                                                                                                                                                                                                                                                                                                        | 'photo.artframe'
                                                                                                                                                                                                                                                                                                                        | 'photo.artframe.circle'
                                                                                                                                                                                                                                                                                                                        | 'photo.artframe.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.arrow.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.magnifyingglass.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.questionmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.shield.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'photo.badge.shield.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.circle'
                                                                                                                                                                                                                                                                                                                        | 'photo.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.fill.on.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'photo.on.rectangle.angled'
                                                                                                                                                                                                                                                                                                                        | 'photo.on.rectangle.angled.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.slash'
                                                                                                                                                                                                                                                                                                                        | 'photo.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.stack'
                                                                                                                                                                                                                                                                                                                        | 'photo.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'photo.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'photo.tv'
                                                                                                                                                                                                                                                                                                                        | 'pi'
                                                                                                                                                                                                                                                                                                                        | 'pi.circle'
                                                                                                                                                                                                                                                                                                                        | 'pi.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pi.square'
                                                                                                                                                                                                                                                                                                                        | 'pi.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'pianokeys'
                                                                                                                                                                                                                                                                                                                        | 'pianokeys.inverse'
                                                                                                                                                                                                                                                                                                                        | 'pill'
                                                                                                                                                                                                                                                                                                                        | 'pill.circle'
                                                                                                                                                                                                                                                                                                                        | 'pill.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pill.fill'
                                                                                                                                                                                                                                                                                                                        | 'pills'
                                                                                                                                                                                                                                                                                                                        | 'pills.circle'
                                                                                                                                                                                                                                                                                                                        | 'pills.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pills.fill'
                                                                                                                                                                                                                                                                                                                        | 'pin'
                                                                                                                                                                                                                                                                                                                        | 'pin.circle'
                                                                                                                                                                                                                                                                                                                        | 'pin.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'pin.fill'
                                                                                                                                                                                                                                                                                                                        | 'pin.slash'
                                                                                                                                                                                                                                                                                                                        | 'pin.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'pin.square'
                                                                                                                                                                                                                                                                                                                        | 'pin.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'pip'
                                                                                                                                                                                                                                                                                                                        | 'pip.enter'
                                                                                                                                                                                                                                                                                                                        | 'pip.exit'
                                                                                                                                                                                                                                                                                                                        | 'pip.fill'
                                                                                                                                                                                                                                                                                                                        | 'pip.remove'
                                                                                                                                                                                                                                                                                                                        | 'pip.swap'
                                                                                                                                                                                                                                                                                                                        | 'pipe.and.drop'
                                                                                                                                                                                                                                                                                                                        | 'pipe.and.drop.fill'
                                                                                                                                                                                                                                                                                                                        | 'pizza.slice'
                                                                                                                                                                                                                                                                                                                        | 'pizza.slice.fill'
                                                                                                                                                                                                                                                                                                                        | 'pl.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'pl.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'placeholdertext.fill'
                                                                                                                                                                                                                                                                                                                        | 'platter.2.filled.ipad'
                                                                                                                                                                                                                                                                                                                        | 'platter.2.filled.ipad.landscape'
                                                                                                                                                                                                                                                                                                                        | 'platter.2.filled.iphone'
                                                                                                                                                                                                                                                                                                                        | 'platter.2.filled.iphone.landscape'
                                                                                                                                                                                                                                                                                                                        | 'platter.bottom.applewatch.case'
                                                                                                                                                                                                                                                                                                                        | 'platter.filled.bottom.and.arrow.down.iphone'
                                                                                                                                                                                                                                                                                                                        | 'platter.filled.bottom.applewatch.case'
                                                                                                                                                                                                                                                                                                                        | 'platter.filled.bottom.iphone'
                                                                                                                                                                                                                                                                                                                        | 'platter.filled.top.and.arrow.up.iphone'
                                                                                                                                                                                                                                                                                                                        | 'platter.filled.top.applewatch.case'
                                                                                                                                                                                                                                                                                                                        | 'platter.filled.top.iphone'
                                                                                                                                                                                                                                                                                                                        | 'platter.top.applewatch.case'
                                                                                                                                                                                                                                                                                                                        | 'play'
                                                                                                                                                                                                                                                                                                                        | 'play.bubble'
                                                                                                                                                                                                                                                                                                                        | 'play.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.bubble.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'play.bubble.rtl'
                                                                                                                                                                                                                                                                                                                        | 'play.circle'
                                                                                                                                                                                                                                                                                                                        | 'play.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.desktopcomputer'
                                                                                                                                                                                                                                                                                                                        | 'play.diamond'
                                                                                                                                                                                                                                                                                                                        | 'play.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.display'
                                                                                                                                                                                                                                                                                                                        | 'play.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.house'
                                                                                                                                                                                                                                                                                                                        | 'play.house.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.laptopcomputer'
                                                                                                                                                                                                                                                                                                                        | 'play.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'play.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.rectangle.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'play.rectangle.on.rectangle.circle'
                                                                                                                                                                                                                                                                                                                        | 'play.rectangle.on.rectangle.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.rectangle.on.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.slash'
                                                                                                                                                                                                                                                                                                                        | 'play.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.square'
                                                                                                                                                                                                                                                                                                                        | 'play.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.square.stack'
                                                                                                                                                                                                                                                                                                                        | 'play.square.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'play.tv'
                                                                                                                                                                                                                                                                                                                        | 'play.tv.fill'
                                                                                                                                                                                                                                                                                                                        | 'playpause'
                                                                                                                                                                                                                                                                                                                        | 'playpause.circle'
                                                                                                                                                                                                                                                                                                                        | 'playpause.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'playpause.fill'
                                                                                                                                                                                                                                                                                                                        | 'playstation.logo'
                                                                                                                                                                                                                                                                                                                        | 'plus'
                                                                                                                                                                                                                                                                                                                        | 'plus.app'
                                                                                                                                                                                                                                                                                                                        | 'plus.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.arrow.trianglehead.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'plus.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | 'plus.bubble'
                                                                                                                                                                                                                                                                                                                        | 'plus.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.capsule'
                                                                                                                                                                                                                                                                                                                        | 'plus.capsule.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.circle'
                                                                                                                                                                                                                                                                                                                        | 'plus.circle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'plus.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.diamond'
                                                                                                                                                                                                                                                                                                                        | 'plus.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.forwardslash.minus'
                                                                                                                                                                                                                                                                                                                        | 'plus.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'plus.message'
                                                                                                                                                                                                                                                                                                                        | 'plus.message.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.minus.capsule'
                                                                                                                                                                                                                                                                                                                        | 'plus.minus.capsule.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'plus.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.rectangle.fill.on.folder.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.rectangle.fill.on.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.rectangle.on.folder'
                                                                                                                                                                                                                                                                                                                        | 'plus.rectangle.on.folder.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.rectangle.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'plus.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'plus.rectangle.portrait.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.slash.minus'
                                                                                                                                                                                                                                                                                                                        | 'plus.square'
                                                                                                                                                                                                                                                                                                                        | 'plus.square.dashed'
                                                                                                                                                                                                                                                                                                                        | 'plus.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.square.fill.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'plus.square.on.square'
                                                                                                                                                                                                                                                                                                                        | 'plus.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'plusminus'
                                                                                                                                                                                                                                                                                                                        | 'plusminus.circle'
                                                                                                                                                                                                                                                                                                                        | 'plusminus.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'point.3.connected.trianglepath.dotted'
                                                                                                                                                                                                                                                                                                                        | 'point.3.filled.connected.trianglepath.dotted'
                                                                                                                                                                                                                                                                                                                        | 'point.bottomleft.filled.forward.to.point.topright.scurvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.bottomleft.forward.to.arrow.triangle.scurvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.bottomleft.forward.to.arrow.triangle.scurvepath.fill'
                                                                                                                                                                                                                                                                                                                        | 'point.bottomleft.forward.to.arrow.triangle.uturn.scurvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.bottomleft.forward.to.arrow.triangle.uturn.scurvepath.fill'
                                                                                                                                                                                                                                                                                                                        | 'point.bottomleft.forward.to.arrowtriangle.uturn.scurvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.bottomleft.forward.to.arrowtriangle.uturn.scurvepath.fill'
                                                                                                                                                                                                                                                                                                                        | 'point.bottomleft.forward.to.point.topright.filled.scurvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.bottomleft.forward.to.point.topright.scurvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.bottomleft.forward.to.point.topright.scurvepath.fill'
                                                                                                                                                                                                                                                                                                                        | 'point.fill.topleft.down.curvedto.point.fill.bottomright.up'
                                                                                                                                                                                                                                                                                                                        | 'point.filled.topleft.down.curvedto.point.bottomright.up'
                                                                                                                                                                                                                                                                                                                        | 'point.forward.to.point.capsulepath'
                                                                                                                                                                                                                                                                                                                        | 'point.forward.to.point.capsulepath.fill'
                                                                                                                                                                                                                                                                                                                        | 'point.topleft.down.curvedto.point.bottomright.up'
                                                                                                                                                                                                                                                                                                                        | 'point.topleft.down.curvedto.point.bottomright.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'point.topleft.down.curvedto.point.filled.bottomright.up'
                                                                                                                                                                                                                                                                                                                        | 'point.topleft.down.to.point.bottomright.curvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.topleft.down.to.point.bottomright.curvepath.fill'
                                                                                                                                                                                                                                                                                                                        | 'point.topleft.down.to.point.bottomright.filled.curvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.topleft.filled.down.to.point.bottomright.curvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.topright.arrow.triangle.backward.to.point.bottomleft.filled.scurvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.topright.arrow.triangle.backward.to.point.bottomleft.scurvepath'
                                                                                                                                                                                                                                                                                                                        | 'point.topright.arrow.triangle.backward.to.point.bottomleft.scurvepath.fill'
                                                                                                                                                                                                                                                                                                                        | 'point.topright.filled.arrow.triangle.backward.to.point.bottomleft.scurvepath'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.and.square.on.square.dashed'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.click'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.click.2'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.click.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.ipad'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.ipad.and.square.on.square.dashed'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.ipad.rays'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.ipad.slash'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.ipad.slash.square'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.ipad.slash.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.ipad.square'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.ipad.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.motionlines'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.motionlines.click'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.rays'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.slash'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.slash.square'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.slash.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.square'
                                                                                                                                                                                                                                                                                                                        | 'pointer.arrow.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.circle'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.ring'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.square'
                                                                                                                                                                                                                                                                                                                        | 'polishzlotysign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'popcorn'
                                                                                                                                                                                                                                                                                                                        | 'popcorn.circle'
                                                                                                                                                                                                                                                                                                                        | 'popcorn.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'popcorn.fill'
                                                                                                                                                                                                                                                                                                                        | 'power'
                                                                                                                                                                                                                                                                                                                        | 'power.circle'
                                                                                                                                                                                                                                                                                                                        | 'power.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'power.dotted'
                                                                                                                                                                                                                                                                                                                        | 'powercord'
                                                                                                                                                                                                                                                                                                                        | 'powercord.fill'
                                                                                                                                                                                                                                                                                                                        | 'powermeter'
                                                                                                                                                                                                                                                                                                                        | 'poweroff'
                                                                                                                                                                                                                                                                                                                        | 'poweron'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.strip'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.strip.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.a'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.a.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.a.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.a.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.b'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.b.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.b.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.b.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.c'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.c.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.c.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.c.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.d'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.d.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.d.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.d.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.e'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.e.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.e.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.e.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.f'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.f.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.f.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.f.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.g'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.g.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.g.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.g.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.h'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.h.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.h.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.h.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.i'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.i.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.i.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.i.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.j'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.j.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.j.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.j.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.k'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.k.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.k.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.k.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.l'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.l.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.l.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.l.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.m'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.m.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.m.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.m.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.n'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.n.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.n.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.n.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.o'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.o.fill'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.o.square'
                                                                                                                                                                                                                                                                                                                        | 'poweroutlet.type.o.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'powerplug'
                                                                                                                                                                                                                                                                                                                        | 'powerplug.fill'
                                                                                                                                                                                                                                                                                                                        | 'powerplug.portrait'
                                                                                                                                                                                                                                                                                                                        | 'powerplug.portrait.fill'
                                                                                                                                                                                                                                                                                                                        | 'powersleep'
                                                                                                                                                                                                                                                                                                                        | 'pr.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'pr.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'printer'
                                                                                                                                                                                                                                                                                                                        | 'printer.dotmatrix'
                                                                                                                                                                                                                                                                                                                        | 'printer.dotmatrix.fill'
                                                                                                                                                                                                                                                                                                                        | 'printer.dotmatrix.fill.and.paper.fill'
                                                                                                                                                                                                                                                                                                                        | 'printer.dotmatrix.filled.and.paper'
                                                                                                                                                                                                                                                                                                                        | 'printer.dotmatrix.filled.and.paper.inverse'
                                                                                                                                                                                                                                                                                                                        | 'printer.dotmatrix.inverse'
                                                                                                                                                                                                                                                                                                                        | 'printer.fill'
                                                                                                                                                                                                                                                                                                                        | 'printer.fill.and.paper.fill'
                                                                                                                                                                                                                                                                                                                        | 'printer.filled.and.paper'
                                                                                                                                                                                                                                                                                                                        | 'printer.filled.and.paper.inverse'
                                                                                                                                                                                                                                                                                                                        | 'printer.inverse'
                                                                                                                                                                                                                                                                                                                        | 'progress.indicator'
                                                                                                                                                                                                                                                                                                                        | 'projective'
                                                                                                                                                                                                                                                                                                                        | 'purchased'
                                                                                                                                                                                                                                                                                                                        | 'purchased.circle'
                                                                                                                                                                                                                                                                                                                        | 'purchased.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'puzzlepiece'
                                                                                                                                                                                                                                                                                                                        | 'puzzlepiece.extension'
                                                                                                                                                                                                                                                                                                                        | 'puzzlepiece.extension.fill'
                                                                                                                                                                                                                                                                                                                        | 'puzzlepiece.fill'
                                                                                                                                                                                                                                                                                                                        | 'pyramid'
                                                                                                                                                                                                                                                                                                                        | 'pyramid.fill'
                                                                                                                                                                                                                                                                                                                        | 'q.circle'
                                                                                                                                                                                                                                                                                                                        | 'q.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'q.square'
                                                                                                                                                                                                                                                                                                                        | 'q.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'qrcode'
                                                                                                                                                                                                                                                                                                                        | 'qrcode.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'questionmark'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.app'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.app.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.app.dashed'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.app.dashed.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.app.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.bubble'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.bubble.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.bubble.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.circle'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.circle.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.circle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.circle.dashed.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.diamond'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.diamond.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.diamond.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.folder'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.folder.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.folder.fill'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.folder.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.key.filled'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.message'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.message.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.message.fill'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.message.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.square'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.square.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.square.dashed'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.square.dashed.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.square.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.text.page'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.text.page.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.text.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.text.page.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.text.page.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.text.page.rtl'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.video'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.video.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.video.fill'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.video.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.video.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'questionmark.video.rtl'
                                                                                                                                                                                                                                                                                                                        | 'quote.bubble'
                                                                                                                                                                                                                                                                                                                        | 'quote.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'quote.bubble.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'quote.bubble.rtl'
                                                                                                                                                                                                                                                                                                                        | 'quote.closing'
                                                                                                                                                                                                                                                                                                                        | 'quote.opening'
                                                                                                                                                                                                                                                                                                                        | 'quotelevel'
                                                                                                                                                                                                                                                                                                                        | 'r.button.roundedbottom.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'r.button.roundedbottom.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.circle'
                                                                                                                                                                                                                                                                                                                        | 'r.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.down'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.press.down'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.press.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.tilt.down'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.tilt.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.tilt.left'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.tilt.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.tilt.right'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.tilt.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.tilt.up'
                                                                                                                                                                                                                                                                                                                        | 'r.joystick.tilt.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.rectangle.roundedbottom'
                                                                                                                                                                                                                                                                                                                        | 'r.rectangle.roundedbottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.square'
                                                                                                                                                                                                                                                                                                                        | 'r.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.square.fill.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'r.square.on.square'
                                                                                                                                                                                                                                                                                                                        | 'r.square.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'r1.button.roundedbottom.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'r1.button.roundedbottom.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'r1.circle'
                                                                                                                                                                                                                                                                                                                        | 'r1.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'r1.rectangle.roundedbottom'
                                                                                                                                                                                                                                                                                                                        | 'r1.rectangle.roundedbottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'r2.button.angledtop.vertical.right'
                                                                                                                                                                                                                                                                                                                        | 'r2.button.angledtop.vertical.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'r2.button.roundedtop.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'r2.button.roundedtop.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'r2.circle'
                                                                                                                                                                                                                                                                                                                        | 'r2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'r2.rectangle.roundedtop'
                                                                                                                                                                                                                                                                                                                        | 'r2.rectangle.roundedtop.fill'
                                                                                                                                                                                                                                                                                                                        | 'r3.button.angledbottom.horizontal.right'
                                                                                                                                                                                                                                                                                                                        | 'r3.button.angledbottom.horizontal.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'r4.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'r4.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'radicand.squareroot'
                                                                                                                                                                                                                                                                                                                        | 'radicand.squareroot.ar'
                                                                                                                                                                                                                                                                                                                        | 'radio'
                                                                                                                                                                                                                                                                                                                        | 'radio.fill'
                                                                                                                                                                                                                                                                                                                        | 'radiowaves.left'
                                                                                                                                                                                                                                                                                                                        | 'radiowaves.right'
                                                                                                                                                                                                                                                                                                                        | 'rainbow'
                                                                                                                                                                                                                                                                                                                        | 'rays'
                                                                                                                                                                                                                                                                                                                        | 'rb.button.roundedbottom.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'rb.button.roundedbottom.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'rb.circle'
                                                                                                                                                                                                                                                                                                                        | 'rb.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rb.rectangle.roundedbottom'
                                                                                                                                                                                                                                                                                                                        | 'rb.rectangle.roundedbottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'receipt'
                                                                                                                                                                                                                                                                                                                        | 'receipt.fill'
                                                                                                                                                                                                                                                                                                                        | 'record.circle'
                                                                                                                                                                                                                                                                                                                        | 'record.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'recordingtape'
                                                                                                                                                                                                                                                                                                                        | 'recordingtape.badge'
                                                                                                                                                                                                                                                                                                                        | 'recordingtape.circle'
                                                                                                                                                                                                                                                                                                                        | 'recordingtape.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.2.swap'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.group'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.group.bubble'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.group.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.group.bubble.left'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.group.bubble.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.group.dashed'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.group.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.offgrid'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.offgrid.bubble.left'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.offgrid.bubble.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.offgrid.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.portrait.pano'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.3.portrait.pano.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.and.arrow.up.right.and.arrow.down.left'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.and.arrow.up.right.and.arrow.down.left.slash'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.and.hand.point.up.left'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.and.hand.point.up.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.and.hand.point.up.left.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.and.paperclip'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.and.pencil.and.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.and.pencil.and.ellipsis.rtl'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.and.text.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.and.text.magnifyingglass.rtl'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.arrowtriangle.2.inward'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.arrowtriangle.2.outward'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.badge.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.badge.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.badge.sparkles.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.bottomhalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.bottomthird.inset.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.bottomthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.center.inset.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.center.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.center.inset.filled.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.checkered'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.compress.vertical'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.connected.to.line.below'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.dashed.and.paperclip'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.dashed.badge.record'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.dock'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.expand.diagonal'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.expand.vertical'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill.badge.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill.on.rectangle.angled.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill.on.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill.on.rectangle.fill.circle'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill.on.rectangle.fill.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.fill.on.rectangle.fill.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.filled.and.hand.point.up.left'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.1x2'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.1x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.1x3'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.1x3.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.2x2'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.2x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.3x1'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.3x1.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.3x2'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.3x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.3x3'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.grid.3x3.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.bottomleading.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.bottomleft.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.bottomleft.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.bottomright.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.bottomright.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.bottomtrailing.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.filled.and.cursorarrow'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.filled.and.person.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.filled.badge.record'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.filled.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.topleading.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.topleft.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.topleft.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.topright.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.topright.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.inset.toptrailing.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.landscape.rotate'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.landscape.rotate.slash'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.leadinghalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.leadinghalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.leadinghalf.inset.filled.arrow.leading'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.leadingthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.lefthalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.lefthalf.inset.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.lefthalf.inset.fill.arrow.left'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.lefthalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.lefthalf.inset.filled.arrow.left'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.leftthird.inset.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.leftthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.angled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.badge.gearshape'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.button.angledtop.vertical.left'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.button.angledtop.vertical.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.circle'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.dashed'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.slash'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.square'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.on.rectangle.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.pattern.checkered'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.and.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.and.arrow.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.and.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.and.arrow.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.arrowtriangle.2.inward'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.arrowtriangle.2.outward'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.bottomhalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.bottomleading.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.bottomleft.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.bottomright.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.bottomthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.bottomtrailing.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.center.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.leadinghalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.leadingthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.lefthalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.leftthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.on.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.on.rectangle.portrait.angled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.on.rectangle.portrait.angled.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.on.rectangle.portrait.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.on.rectangle.portrait.slash'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.on.rectangle.portrait.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.righthalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.rightthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.rotate'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.rotate.slash'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.slash'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.split.2x1'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.split.2x1.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.split.2x1.slash'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.split.2x1.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.tophalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.topleading.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.topleft.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.topright.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.topthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.toptrailing.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.trailinghalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.portrait.trailingthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.ratio.16.to.9'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.ratio.16.to.9.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.ratio.3.to.4'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.ratio.3.to.4.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.ratio.4.to.3'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.ratio.4.to.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.ratio.9.to.16'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.ratio.9.to.16.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.righthalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.righthalf.inset.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.righthalf.inset.fill.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.righthalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.righthalf.inset.filled.arrow.right'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.rightthird.inset.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.rightthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.roundedbottom'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.roundedbottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.roundedtop'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.roundedtop.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.slash'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.1x2'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.1x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.2x1'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.2x1.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.2x1.slash'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.2x1.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.2x2'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.2x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.3x1'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.3x1.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.3x3'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.split.3x3.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.and.person'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.and.person.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.badge.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.badge.person.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.badge.play.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.fill.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.fill.badge.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.person.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.slash'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.stack.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.tophalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.topthird.inset'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.topthird.inset.fill'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.topthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.trailinghalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.trailinghalf.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.trailinghalf.inset.filled.arrow.trailing'
                                                                                                                                                                                                                                                                                                                        | 'rectangle.trailingthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'refrigerator'
                                                                                                                                                                                                                                                                                                                        | 'refrigerator.fill'
                                                                                                                                                                                                                                                                                                                        | 'repeat'
                                                                                                                                                                                                                                                                                                                        | 'repeat.1'
                                                                                                                                                                                                                                                                                                                        | 'repeat.1.ar'
                                                                                                                                                                                                                                                                                                                        | 'repeat.1.circle'
                                                                                                                                                                                                                                                                                                                        | 'repeat.1.circle.ar'
                                                                                                                                                                                                                                                                                                                        | 'repeat.1.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'repeat.1.circle.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'repeat.1.circle.fill.hi'
                                                                                                                                                                                                                                                                                                                        | 'repeat.1.circle.hi'
                                                                                                                                                                                                                                                                                                                        | 'repeat.1.hi'
                                                                                                                                                                                                                                                                                                                        | 'repeat.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'repeat.badge.xmark.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'repeat.circle'
                                                                                                                                                                                                                                                                                                                        | 'repeat.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'restart'
                                                                                                                                                                                                                                                                                                                        | 'restart.circle'
                                                                                                                                                                                                                                                                                                                        | 'restart.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'retarder.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'retarder.brakesignal.and.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'retarder.brakesignal.slash'
                                                                                                                                                                                                                                                                                                                        | 'return'
                                                                                                                                                                                                                                                                                                                        | 'return.left'
                                                                                                                                                                                                                                                                                                                        | 'return.right'
                                                                                                                                                                                                                                                                                                                        | 'rhombus'
                                                                                                                                                                                                                                                                                                                        | 'rhombus.fill'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.ar'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.fill.he'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.fill.hi'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.fill.ja'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.fill.ko'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.fill.th'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.fill.zh'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.he'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.hi'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.ja'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.ko'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.th'
                                                                                                                                                                                                                                                                                                                        | 'richtext.page.zh'
                                                                                                                                                                                                                                                                                                                        | 'right'
                                                                                                                                                                                                                                                                                                                        | 'right.circle'
                                                                                                                                                                                                                                                                                                                        | 'right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'righttriangle'
                                                                                                                                                                                                                                                                                                                        | 'righttriangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'righttriangle.split.diagonal'
                                                                                                                                                                                                                                                                                                                        | 'righttriangle.split.diagonal.fill'
                                                                                                                                                                                                                                                                                                                        | 'ring'
                                                                                                                                                                                                                                                                                                                        | 'ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'ring.light'
                                                                                                                                                                                                                                                                                                                        | 'rm.button.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'rm.button.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'road.lane.arrowtriangle.2.inward'
                                                                                                                                                                                                                                                                                                                        | 'road.lane.arrowtriangle.2.outward'
                                                                                                                                                                                                                                                                                                                        | 'road.lanes'
                                                                                                                                                                                                                                                                                                                        | 'road.lanes.curved.left'
                                                                                                                                                                                                                                                                                                                        | 'road.lanes.curved.right'
                                                                                                                                                                                                                                                                                                                        | 'robotic.vacuum'
                                                                                                                                                                                                                                                                                                                        | 'robotic.vacuum.and.arrowtriangle.up'
                                                                                                                                                                                                                                                                                                                        | 'robotic.vacuum.and.arrowtriangle.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'robotic.vacuum.and.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'robotic.vacuum.and.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'robotic.vacuum.fill'
                                                                                                                                                                                                                                                                                                                        | 'roller.shade.closed'
                                                                                                                                                                                                                                                                                                                        | 'roller.shade.open'
                                                                                                                                                                                                                                                                                                                        | 'roman.shade.closed'
                                                                                                                                                                                                                                                                                                                        | 'roman.shade.open'
                                                                                                                                                                                                                                                                                                                        | 'rosette'
                                                                                                                                                                                                                                                                                                                        | 'rotate.3d'
                                                                                                                                                                                                                                                                                                                        | 'rotate.3d.circle'
                                                                                                                                                                                                                                                                                                                        | 'rotate.3d.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rotate.3d.fill'
                                                                                                                                                                                                                                                                                                                        | 'rotate.left'
                                                                                                                                                                                                                                                                                                                        | 'rotate.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'rotate.right'
                                                                                                                                                                                                                                                                                                                        | 'rotate.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'rsb.button.angledbottom.horizontal.right'
                                                                                                                                                                                                                                                                                                                        | 'rsb.button.angledbottom.horizontal.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'rt.button.roundedtop.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'rt.button.roundedtop.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'rt.circle'
                                                                                                                                                                                                                                                                                                                        | 'rt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rt.rectangle.roundedtop'
                                                                                                                                                                                                                                                                                                                        | 'rt.rectangle.roundedtop.fill'
                                                                                                                                                                                                                                                                                                                        | 'rublesign'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.circle'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.ring'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.square'
                                                                                                                                                                                                                                                                                                                        | 'rublesign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'rugbyball'
                                                                                                                                                                                                                                                                                                                        | 'rugbyball.circle'
                                                                                                                                                                                                                                                                                                                        | 'rugbyball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rugbyball.fill'
                                                                                                                                                                                                                                                                                                                        | 'ruler'
                                                                                                                                                                                                                                                                                                                        | 'ruler.fill'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.circle'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.ring'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.square'
                                                                                                                                                                                                                                                                                                                        | 'rupeesign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 's.circle'
                                                                                                                                                                                                                                                                                                                        | 's.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 's.square'
                                                                                                                                                                                                                                                                                                                        | 's.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'safari'
                                                                                                                                                                                                                                                                                                                        | 'safari.fill'
                                                                                                                                                                                                                                                                                                                        | 'sailboat'
                                                                                                                                                                                                                                                                                                                        | 'sailboat.circle'
                                                                                                                                                                                                                                                                                                                        | 'sailboat.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sailboat.fill'
                                                                                                                                                                                                                                                                                                                        | 'scale.3d'
                                                                                                                                                                                                                                                                                                                        | 'scalemass'
                                                                                                                                                                                                                                                                                                                        | 'scalemass.fill'
                                                                                                                                                                                                                                                                                                                        | 'scanner'
                                                                                                                                                                                                                                                                                                                        | 'scanner.fill'
                                                                                                                                                                                                                                                                                                                        | 'scissors'
                                                                                                                                                                                                                                                                                                                        | 'scissors.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'scissors.circle'
                                                                                                                                                                                                                                                                                                                        | 'scissors.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'scooter'
                                                                                                                                                                                                                                                                                                                        | 'scope'
                                                                                                                                                                                                                                                                                                                        | 'scope.continuous'
                                                                                                                                                                                                                                                                                                                        | 'screwdriver'
                                                                                                                                                                                                                                                                                                                        | 'screwdriver.fill'
                                                                                                                                                                                                                                                                                                                        | 'scribble'
                                                                                                                                                                                                                                                                                                                        | 'scribble.variable'
                                                                                                                                                                                                                                                                                                                        | 'scroll'
                                                                                                                                                                                                                                                                                                                        | 'scroll.fill'
                                                                                                                                                                                                                                                                                                                        | 'sdcard'
                                                                                                                                                                                                                                                                                                                        | 'sdcard.fill'
                                                                                                                                                                                                                                                                                                                        | 'seal'
                                                                                                                                                                                                                                                                                                                        | 'seal.fill'
                                                                                                                                                                                                                                                                                                                        | 'selection.pin.in.out'
                                                                                                                                                                                                                                                                                                                        | 'sensor'
                                                                                                                                                                                                                                                                                                                        | 'sensor.fill'
                                                                                                                                                                                                                                                                                                                        | 'sensor.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'sensor.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'sensor.tag.radiowaves.forward'
                                                                                                                                                                                                                                                                                                                        | 'sensor.tag.radiowaves.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'server.rack'
                                                                                                                                                                                                                                                                                                                        | 'service.dog'
                                                                                                                                                                                                                                                                                                                        | 'service.dog.fill'
                                                                                                                                                                                                                                                                                                                        | 'shadow'
                                                                                                                                                                                                                                                                                                                        | 'shared.with.you'
                                                                                                                                                                                                                                                                                                                        | 'shared.with.you.circle'
                                                                                                                                                                                                                                                                                                                        | 'shared.with.you.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'shared.with.you.slash'
                                                                                                                                                                                                                                                                                                                        | 'sharedwithyou'
                                                                                                                                                                                                                                                                                                                        | 'sharedwithyou.circle'
                                                                                                                                                                                                                                                                                                                        | 'sharedwithyou.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sharedwithyou.slash'
                                                                                                                                                                                                                                                                                                                        | 'shareplay'
                                                                                                                                                                                                                                                                                                                        | 'shareplay.slash'
                                                                                                                                                                                                                                                                                                                        | 'shazam.logo'
                                                                                                                                                                                                                                                                                                                        | 'shazam.logo.fill'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.square'
                                                                                                                                                                                                                                                                                                                        | 'shekelsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'sheqelsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'sheqelsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sheqelsign.square'
                                                                                                                                                                                                                                                                                                                        | 'sheqelsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'shield'
                                                                                                                                                                                                                                                                                                                        | 'shield.checkerboard'
                                                                                                                                                                                                                                                                                                                        | 'shield.checkered'
                                                                                                                                                                                                                                                                                                                        | 'shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'shield.lefthalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'shield.lefthalf.fill.slash'
                                                                                                                                                                                                                                                                                                                        | 'shield.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'shield.lefthalf.filled.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'shield.lefthalf.filled.slash'
                                                                                                                                                                                                                                                                                                                        | 'shield.lefthalf.filled.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'shield.pattern.checkered'
                                                                                                                                                                                                                                                                                                                        | 'shield.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'shield.slash'
                                                                                                                                                                                                                                                                                                                        | 'shield.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'shift'
                                                                                                                                                                                                                                                                                                                        | 'shift.fill'
                                                                                                                                                                                                                                                                                                                        | 'shippingbox'
                                                                                                                                                                                                                                                                                                                        | 'shippingbox.and.arrow.backward'
                                                                                                                                                                                                                                                                                                                        | 'shippingbox.and.arrow.backward.fill'
                                                                                                                                                                                                                                                                                                                        | 'shippingbox.circle'
                                                                                                                                                                                                                                                                                                                        | 'shippingbox.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'shippingbox.fill'
                                                                                                                                                                                                                                                                                                                        | 'shoe'
                                                                                                                                                                                                                                                                                                                        | 'shoe.2'
                                                                                                                                                                                                                                                                                                                        | 'shoe.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'shoe.arrow.trianglehead.up.and.down'
                                                                                                                                                                                                                                                                                                                        | 'shoe.arrow.trianglehead.up.and.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'shoe.arrow.trianglehead.up.right'
                                                                                                                                                                                                                                                                                                                        | 'shoe.arrow.trianglehead.up.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'shoe.arrow.trianglehead.up.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'shoe.arrow.trianglehead.up.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'shoe.circle'
                                                                                                                                                                                                                                                                                                                        | 'shoe.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'shoe.fill'
                                                                                                                                                                                                                                                                                                                        | 'shoe.running.and.shadow.fill'
                                                                                                                                                                                                                                                                                                                        | 'shoeprints.fill'
                                                                                                                                                                                                                                                                                                                        | 'shower'
                                                                                                                                                                                                                                                                                                                        | 'shower.fill'
                                                                                                                                                                                                                                                                                                                        | 'shower.handheld'
                                                                                                                                                                                                                                                                                                                        | 'shower.handheld.fill'
                                                                                                                                                                                                                                                                                                                        | 'shower.sidejet'
                                                                                                                                                                                                                                                                                                                        | 'shower.sidejet.fill'
                                                                                                                                                                                                                                                                                                                        | 'shuffle'
                                                                                                                                                                                                                                                                                                                        | 'shuffle.circle'
                                                                                                                                                                                                                                                                                                                        | 'shuffle.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sidebar.leading'
                                                                                                                                                                                                                                                                                                                        | 'sidebar.left'
                                                                                                                                                                                                                                                                                                                        | 'sidebar.right'
                                                                                                                                                                                                                                                                                                                        | 'sidebar.squares.leading'
                                                                                                                                                                                                                                                                                                                        | 'sidebar.squares.left'
                                                                                                                                                                                                                                                                                                                        | 'sidebar.squares.right'
                                                                                                                                                                                                                                                                                                                        | 'sidebar.squares.trailing'
                                                                                                                                                                                                                                                                                                                        | 'sidebar.trailing'
                                                                                                                                                                                                                                                                                                                        | 'signature'
                                                                                                                                                                                                                                                                                                                        | 'signature.ar'
                                                                                                                                                                                                                                                                                                                        | 'signature.he'
                                                                                                                                                                                                                                                                                                                        | 'signature.ja'
                                                                                                                                                                                                                                                                                                                        | 'signature.th'
                                                                                                                                                                                                                                                                                                                        | 'signature.zh'
                                                                                                                                                                                                                                                                                                                        | 'signpost.and.arrowtriangle.up'
                                                                                                                                                                                                                                                                                                                        | 'signpost.and.arrowtriangle.up.circle'
                                                                                                                                                                                                                                                                                                                        | 'signpost.and.arrowtriangle.up.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'signpost.and.arrowtriangle.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'signpost.left'
                                                                                                                                                                                                                                                                                                                        | 'signpost.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'signpost.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'signpost.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'signpost.right'
                                                                                                                                                                                                                                                                                                                        | 'signpost.right.and.left'
                                                                                                                                                                                                                                                                                                                        | 'signpost.right.and.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'signpost.right.and.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'signpost.right.and.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'signpost.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'signpost.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'signpost.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'simcard'
                                                                                                                                                                                                                                                                                                                        | 'simcard.2'
                                                                                                                                                                                                                                                                                                                        | 'simcard.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'simcard.fill'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.square'
                                                                                                                                                                                                                                                                                                                        | 'singaporedollarsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'sink'
                                                                                                                                                                                                                                                                                                                        | 'sink.fill'
                                                                                                                                                                                                                                                                                                                        | 'siri'
                                                                                                                                                                                                                                                                                                                        | 'siri.gen1'
                                                                                                                                                                                                                                                                                                                        | 'siri.gen2'
                                                                                                                                                                                                                                                                                                                        | 'skateboard'
                                                                                                                                                                                                                                                                                                                        | 'skateboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'skew'
                                                                                                                                                                                                                                                                                                                        | 'skis'
                                                                                                                                                                                                                                                                                                                        | 'skis.fill'
                                                                                                                                                                                                                                                                                                                        | 'slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sleep'
                                                                                                                                                                                                                                                                                                                        | 'sleep.circle'
                                                                                                                                                                                                                                                                                                                        | 'sleep.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.2.arrow.trianglehead.counterclockwise'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.2.gobackward'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.2.rectangle.and.arrow.triangle.2.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.2.rectangle.and.arrow.trianglehead.2.clockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.2.square'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.2.square.badge.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.2.square.on.square'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.3'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.below.circle.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.below.circle.lefthalf.filled.inverse'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.below.circle.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.below.circle.righthalf.filled.inverse'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.below.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.below.square.and.square.filled'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.below.square.fill.and.square'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.below.square.filled.and.square'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.below.sun.max'
                                                                                                                                                                                                                                                                                                                        | 'slider.horizontal.below.sun.min'
                                                                                                                                                                                                                                                                                                                        | 'slider.vertical.3'
                                                                                                                                                                                                                                                                                                                        | 'slowmo'
                                                                                                                                                                                                                                                                                                                        | 'smallcircle.circle'
                                                                                                                                                                                                                                                                                                                        | 'smallcircle.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'smallcircle.fill.circle'
                                                                                                                                                                                                                                                                                                                        | 'smallcircle.fill.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'smallcircle.filled.circle'
                                                                                                                                                                                                                                                                                                                        | 'smallcircle.filled.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'smartphone'
                                                                                                                                                                                                                                                                                                                        | 'smiley'
                                                                                                                                                                                                                                                                                                                        | 'smiley.fill'
                                                                                                                                                                                                                                                                                                                        | 'smoke'
                                                                                                                                                                                                                                                                                                                        | 'smoke.circle'
                                                                                                                                                                                                                                                                                                                        | 'smoke.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'smoke.fill'
                                                                                                                                                                                                                                                                                                                        | 'snow'
                                                                                                                                                                                                                                                                                                                        | 'snowboard'
                                                                                                                                                                                                                                                                                                                        | 'snowboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'snowflake'
                                                                                                                                                                                                                                                                                                                        | 'snowflake.circle'
                                                                                                                                                                                                                                                                                                                        | 'snowflake.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'snowflake.road.lane'
                                                                                                                                                                                                                                                                                                                        | 'snowflake.road.lane.dashed'
                                                                                                                                                                                                                                                                                                                        | 'snowflake.slash'
                                                                                                                                                                                                                                                                                                                        | 'soccerball'
                                                                                                                                                                                                                                                                                                                        | 'soccerball.circle'
                                                                                                                                                                                                                                                                                                                        | 'soccerball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'soccerball.circle.fill.inverse'
                                                                                                                                                                                                                                                                                                                        | 'soccerball.circle.inverse'
                                                                                                                                                                                                                                                                                                                        | 'soccerball.inverse'
                                                                                                                                                                                                                                                                                                                        | 'sofa'
                                                                                                                                                                                                                                                                                                                        | 'sofa.fill'
                                                                                                                                                                                                                                                                                                                        | 'sos'
                                                                                                                                                                                                                                                                                                                        | 'sos.circle'
                                                                                                                                                                                                                                                                                                                        | 'sos.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'space'
                                                                                                                                                                                                                                                                                                                        | 'sparkle'
                                                                                                                                                                                                                                                                                                                        | 'sparkle.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'sparkle.text.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'sparkle.text.clipboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'sparkles'
                                                                                                                                                                                                                                                                                                                        | 'sparkles.2'
                                                                                                                                                                                                                                                                                                                        | 'sparkles.rectangle.stack'
                                                                                                                                                                                                                                                                                                                        | 'sparkles.rectangle.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'sparkles.square.fill.on.square'
                                                                                                                                                                                                                                                                                                                        | 'sparkles.square.filled.on.square'
                                                                                                                                                                                                                                                                                                                        | 'sparkles.tv'
                                                                                                                                                                                                                                                                                                                        | 'sparkles.tv.fill'
                                                                                                                                                                                                                                                                                                                        | 'spatial.capture'
                                                                                                                                                                                                                                                                                                                        | 'spatial.capture.fill'
                                                                                                                                                                                                                                                                                                                        | 'spatial.capture.on.hexagon'
                                                                                                                                                                                                                                                                                                                        | 'spatial.capture.on.hexagon.fill'
                                                                                                                                                                                                                                                                                                                        | 'spatial.capture.slash'
                                                                                                                                                                                                                                                                                                                        | 'spatial.capture.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker'
                                                                                                                                                                                                                                                                                                                        | 'speaker.1'
                                                                                                                                                                                                                                                                                                                        | 'speaker.1.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.2'
                                                                                                                                                                                                                                                                                                                        | 'speaker.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.3'
                                                                                                                                                                                                                                                                                                                        | 'speaker.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'speaker.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.circle'
                                                                                                                                                                                                                                                                                                                        | 'speaker.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.minus'
                                                                                                                                                                                                                                                                                                                        | 'speaker.minus.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.plus'
                                                                                                                                                                                                                                                                                                                        | 'speaker.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.slash'
                                                                                                                                                                                                                                                                                                                        | 'speaker.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'speaker.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.slash.circle.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'speaker.slash.circle.rtl'
                                                                                                                                                                                                                                                                                                                        | 'speaker.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.slash.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'speaker.slash.rtl'
                                                                                                                                                                                                                                                                                                                        | 'speaker.square'
                                                                                                                                                                                                                                                                                                                        | 'speaker.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'speaker.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.1'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.1.arrowtriangles.up.right.down.left'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.1.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.bubble'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.bubble.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.bubble.left'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.bubble.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.bubble.left.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.bubble.left.rtl'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.bubble.rtl'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.circle'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.3'
                                                                                                                                                                                                                                                                                                                        | 'speaker.wave.3.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.zzz'
                                                                                                                                                                                                                                                                                                                        | 'speaker.zzz.fill'
                                                                                                                                                                                                                                                                                                                        | 'speaker.zzz.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'speaker.zzz.rtl'
                                                                                                                                                                                                                                                                                                                        | 'speedometer'
                                                                                                                                                                                                                                                                                                                        | 'spigot'
                                                                                                                                                                                                                                                                                                                        | 'spigot.fill'
                                                                                                                                                                                                                                                                                                                        | 'spoon.serving'
                                                                                                                                                                                                                                                                                                                        | 'sportscourt'
                                                                                                                                                                                                                                                                                                                        | 'sportscourt.circle'
                                                                                                                                                                                                                                                                                                                        | 'sportscourt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sportscourt.fill'
                                                                                                                                                                                                                                                                                                                        | 'sprinkler'
                                                                                                                                                                                                                                                                                                                        | 'sprinkler.and.droplets'
                                                                                                                                                                                                                                                                                                                        | 'sprinkler.and.droplets.fill'
                                                                                                                                                                                                                                                                                                                        | 'sprinkler.fill'
                                                                                                                                                                                                                                                                                                                        | 'square'
                                                                                                                                                                                                                                                                                                                        | 'square.2.layers.3d'
                                                                                                                                                                                                                                                                                                                        | 'square.2.layers.3d.bottom.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.2.layers.3d.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.2.layers.3d.top.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.2.stack.3d'
                                                                                                                                                                                                                                                                                                                        | 'square.2.stack.3d.bottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.2.stack.3d.bottom.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.2.stack.3d.top.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.2.stack.3d.top.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.bottom.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.down.backward'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.down.backward.slash.rtl'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.down.forward'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.down.forward.slash.rtl'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.down.left'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.down.left.slash'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.down.right'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.down.right.slash'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.middle.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.slash'
                                                                                                                                                                                                                                                                                                                        | 'square.3.layers.3d.top.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.3.stack.3d'
                                                                                                                                                                                                                                                                                                                        | 'square.3.stack.3d.bottom.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.3.stack.3d.bottom.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.3.stack.3d.middle.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.3.stack.3d.middle.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.3.stack.3d.slash'
                                                                                                                                                                                                                                                                                                                        | 'square.3.stack.3d.top.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.3.stack.3d.top.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.down.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.down.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.down.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.down.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.down.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.down.badge.xmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.down.on.square'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.down.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.circle'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.on.square'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'square.and.arrow.up.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.at.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'square.and.at.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.line.vertical.and.square'
                                                                                                                                                                                                                                                                                                                        | 'square.and.line.vertical.and.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.and.line.vertical.and.square.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.and.pencil'
                                                                                                                                                                                                                                                                                                                        | 'square.and.pencil.circle'
                                                                                                                                                                                                                                                                                                                        | 'square.and.pencil.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.arrowtriangle.4.outward'
                                                                                                                                                                                                                                                                                                                        | 'square.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'square.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.bottomhalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.bottomthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.circle'
                                                                                                                                                                                                                                                                                                                        | 'square.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.dashed'
                                                                                                                                                                                                                                                                                                                        | 'square.dashed.inset.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.dashed.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.dashed.micro'
                                                                                                                                                                                                                                                                                                                        | 'square.dotted'
                                                                                                                                                                                                                                                                                                                        | 'square.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.fill.and.line.vertical.and.square'
                                                                                                                                                                                                                                                                                                                        | 'square.fill.and.line.vertical.and.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.fill.and.line.vertical.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.fill.on.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.fill.on.square'
                                                                                                                                                                                                                                                                                                                        | 'square.fill.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.fill.text.grid.1x2'
                                                                                                                                                                                                                                                                                                                        | 'square.filled.and.line.vertical.and.square'
                                                                                                                                                                                                                                                                                                                        | 'square.filled.on.square'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.2x2'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.2x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x1.below.line.grid.1x2'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x1.below.line.grid.1x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x1.fill.below.line.grid.1x2'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x1.folder.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x1.folder.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x2'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.bottomleft.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.bottomleft.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.bottommiddle.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.bottommiddle.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.bottomright.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.bottomright.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.fill.square'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.middle.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.middle.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.middleleft.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.middleleft.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.middleright.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.middleright.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.square'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.square.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.topleft.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.topleft.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.topmiddle.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.topmiddle.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.topright.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.3x3.topright.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.4x3.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.grid.month'
                                                                                                                                                                                                                                                                                                                        | 'square.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.leadingthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.lefthalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.leftthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.on.circle'
                                                                                                                                                                                                                                                                                                                        | 'square.on.square'
                                                                                                                                                                                                                                                                                                                        | 'square.on.square.badge.person.crop'
                                                                                                                                                                                                                                                                                                                        | 'square.on.square.badge.person.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.on.square.dashed'
                                                                                                                                                                                                                                                                                                                        | 'square.on.square.intersection.dashed'
                                                                                                                                                                                                                                                                                                                        | 'square.on.square.squareshape.controlhandles'
                                                                                                                                                                                                                                                                                                                        | 'square.resize'
                                                                                                                                                                                                                                                                                                                        | 'square.resize.down'
                                                                                                                                                                                                                                                                                                                        | 'square.resize.up'
                                                                                                                                                                                                                                                                                                                        | 'square.righthalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.rightthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.slash'
                                                                                                                                                                                                                                                                                                                        | 'square.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.split.1x2'
                                                                                                                                                                                                                                                                                                                        | 'square.split.1x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.split.2x1'
                                                                                                                                                                                                                                                                                                                        | 'square.split.2x1.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.split.2x2'
                                                                                                                                                                                                                                                                                                                        | 'square.split.2x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.split.bottomrightquarter'
                                                                                                                                                                                                                                                                                                                        | 'square.split.bottomrightquarter.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.split.diagonal'
                                                                                                                                                                                                                                                                                                                        | 'square.split.diagonal.2x2'
                                                                                                                                                                                                                                                                                                                        | 'square.split.diagonal.2x2.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.split.diagonal.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.stack'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.down.dottedline'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.down.forward'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.down.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.down.right'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.down.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.forward.dottedline'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.forward.dottedline.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.up'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.up.badge.a'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.up.badge.a.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.up.badge.automatic'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.up.badge.automatic.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.up.slash'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.up.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.up.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.3d.up.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.stack.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.text.square'
                                                                                                                                                                                                                                                                                                                        | 'square.text.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.tophalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'square.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.topthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'square.trailingthird.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'squareroot'
                                                                                                                                                                                                                                                                                                                        | 'squares.below.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'squares.leading.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'squares.leading.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'squareshape'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.controlhandles.on.squareshape.controlhandles'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.dashed.squareshape'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.dotted.split.2x2'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.dotted.squareshape'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.fill'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.on.pattern.diagonalline'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.split.2x2'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.split.2x2.dotted'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.split.2x2.dotted.inside'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.split.2x2.dotted.inside.and.outside'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.split.2x2.dotted.outside'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.split.3x3'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.squareshape.dashed'
                                                                                                                                                                                                                                                                                                                        | 'squareshape.squareshape.dotted'
                                                                                                                                                                                                                                                                                                                        | 'stairs'
                                                                                                                                                                                                                                                                                                                        | 'star'
                                                                                                                                                                                                                                                                                                                        | 'star.bubble'
                                                                                                                                                                                                                                                                                                                        | 'star.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'star.calendar'
                                                                                                                                                                                                                                                                                                                        | 'star.circle'
                                                                                                                                                                                                                                                                                                                        | 'star.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'star.fill'
                                                                                                                                                                                                                                                                                                                        | 'star.hexagon'
                                                                                                                                                                                                                                                                                                                        | 'star.hexagon.fill'
                                                                                                                                                                                                                                                                                                                        | 'star.leadinghalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'star.leadinghalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'star.lefthalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'star.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'star.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'star.slash'
                                                                                                                                                                                                                                                                                                                        | 'star.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'star.square'
                                                                                                                                                                                                                                                                                                                        | 'star.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'star.square.on.square'
                                                                                                                                                                                                                                                                                                                        | 'star.square.on.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'staroflife'
                                                                                                                                                                                                                                                                                                                        | 'staroflife.circle'
                                                                                                                                                                                                                                                                                                                        | 'staroflife.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'staroflife.fill'
                                                                                                                                                                                                                                                                                                                        | 'staroflife.shield'
                                                                                                                                                                                                                                                                                                                        | 'staroflife.shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.and.hands'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.and.key'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.and.liquid.wave'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.and.lock'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.arrow.trianglehead.counterclockwise.and.clockwise'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.arrowtriangle.left'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.arrowtriangle.right'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.badge.lock'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.circle'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.road.lane'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.road.lane.dashed'
                                                                                                                                                                                                                                                                                                                        | 'steeringwheel.slash'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.square'
                                                                                                                                                                                                                                                                                                                        | 'sterlingsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'stethoscope'
                                                                                                                                                                                                                                                                                                                        | 'stethoscope.circle'
                                                                                                                                                                                                                                                                                                                        | 'stethoscope.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'stop'
                                                                                                                                                                                                                                                                                                                        | 'stop.circle'
                                                                                                                                                                                                                                                                                                                        | 'stop.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'stop.fill'
                                                                                                                                                                                                                                                                                                                        | 'stopwatch'
                                                                                                                                                                                                                                                                                                                        | 'stopwatch.fill'
                                                                                                                                                                                                                                                                                                                        | 'storefront'
                                                                                                                                                                                                                                                                                                                        | 'storefront.circle'
                                                                                                                                                                                                                                                                                                                        | 'storefront.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'storefront.fill'
                                                                                                                                                                                                                                                                                                                        | 'stove'
                                                                                                                                                                                                                                                                                                                        | 'stove.fill'
                                                                                                                                                                                                                                                                                                                        | 'strikethrough'
                                                                                                                                                                                                                                                                                                                        | 'strikethrough.double'
                                                                                                                                                                                                                                                                                                                        | 'stroke.line.diagonal'
                                                                                                                                                                                                                                                                                                                        | 'stroke.line.diagonal.slash'
                                                                                                                                                                                                                                                                                                                        | 'stroller'
                                                                                                                                                                                                                                                                                                                        | 'stroller.fill'
                                                                                                                                                                                                                                                                                                                        | 'studentdesk'
                                                                                                                                                                                                                                                                                                                        | 'suit.club'
                                                                                                                                                                                                                                                                                                                        | 'suit.club.fill'
                                                                                                                                                                                                                                                                                                                        | 'suit.diamond'
                                                                                                                                                                                                                                                                                                                        | 'suit.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'suit.heart'
                                                                                                                                                                                                                                                                                                                        | 'suit.heart.fill'
                                                                                                                                                                                                                                                                                                                        | 'suit.spade'
                                                                                                                                                                                                                                                                                                                        | 'suit.spade.fill'
                                                                                                                                                                                                                                                                                                                        | 'suitcase'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.cart'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.cart.fill'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.circle'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.and.film'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.and.film.circle'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.and.film.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.and.film.fill'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.and.suitcase'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.and.suitcase.circle'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.and.suitcase.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.and.suitcase.fill'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.circle'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'suitcase.rolling.fill'
                                                                                                                                                                                                                                                                                                                        | 'sum'
                                                                                                                                                                                                                                                                                                                        | 'sum.ar'
                                                                                                                                                                                                                                                                                                                        | 'sun.and.horizon'
                                                                                                                                                                                                                                                                                                                        | 'sun.and.horizon.circle'
                                                                                                                                                                                                                                                                                                                        | 'sun.and.horizon.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.and.horizon.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.dust'
                                                                                                                                                                                                                                                                                                                        | 'sun.dust.circle'
                                                                                                                                                                                                                                                                                                                        | 'sun.dust.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.dust.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.haze'
                                                                                                                                                                                                                                                                                                                        | 'sun.haze.circle'
                                                                                                                                                                                                                                                                                                                        | 'sun.haze.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.haze.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.horizon'
                                                                                                                                                                                                                                                                                                                        | 'sun.horizon.circle'
                                                                                                                                                                                                                                                                                                                        | 'sun.horizon.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.horizon.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'sun.max'
                                                                                                                                                                                                                                                                                                                        | 'sun.max.circle'
                                                                                                                                                                                                                                                                                                                        | 'sun.max.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.max.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.max.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'sun.max.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.min'
                                                                                                                                                                                                                                                                                                                        | 'sun.min.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.rain'
                                                                                                                                                                                                                                                                                                                        | 'sun.rain.circle'
                                                                                                                                                                                                                                                                                                                        | 'sun.rain.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.rain.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'sun.snow'
                                                                                                                                                                                                                                                                                                                        | 'sun.snow.circle'
                                                                                                                                                                                                                                                                                                                        | 'sun.snow.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sun.snow.fill'
                                                                                                                                                                                                                                                                                                                        | 'sunglasses'
                                                                                                                                                                                                                                                                                                                        | 'sunglasses.fill'
                                                                                                                                                                                                                                                                                                                        | 'sunrise'
                                                                                                                                                                                                                                                                                                                        | 'sunrise.circle'
                                                                                                                                                                                                                                                                                                                        | 'sunrise.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sunrise.fill'
                                                                                                                                                                                                                                                                                                                        | 'sunset'
                                                                                                                                                                                                                                                                                                                        | 'sunset.circle'
                                                                                                                                                                                                                                                                                                                        | 'sunset.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'sunset.fill'
                                                                                                                                                                                                                                                                                                                        | 'surfboard'
                                                                                                                                                                                                                                                                                                                        | 'surfboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'suspension.shock'
                                                                                                                                                                                                                                                                                                                        | 'suv.side'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.air.circulate'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.air.circulate.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.air.fresh'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.air.fresh.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.and.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.and.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.arrow.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.arrow.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.arrowtriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.arrowtriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.arrowtriangle.up'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.arrowtriangle.up.arrowtriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.arrowtriangle.up.arrowtriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.arrowtriangle.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.front.open'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.front.open.crop'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.front.open.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.front.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.hill.descent.control'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.hill.descent.control.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.hill.down'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.hill.down.and.gauge.open.with.lines.needle.25percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.hill.down.and.gauge.open.with.lines.needle.25percent.and.arrowtriangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.hill.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.hill.up'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.hill.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.lock'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.lock.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.lock.open'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.lock.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.rear.open'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.rear.open.crop'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.rear.open.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.rear.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.roof.cargo.carrier'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.roof.cargo.carrier.fill'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.roof.cargo.carrier.slash'
                                                                                                                                                                                                                                                                                                                        | 'suv.side.roof.cargo.carrier.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'swatchpalette'
                                                                                                                                                                                                                                                                                                                        | 'swatchpalette.fill'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.circle'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.ring'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.square'
                                                                                                                                                                                                                                                                                                                        | 'swedishkronasign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'swift'
                                                                                                                                                                                                                                                                                                                        | 'swiftdata'
                                                                                                                                                                                                                                                                                                                        | 'swirl.circle.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'swirl.circle.righthalf.filled.inverse'
                                                                                                                                                                                                                                                                                                                        | 'switch.2'
                                                                                                                                                                                                                                                                                                                        | 'switch.programmable'
                                                                                                                                                                                                                                                                                                                        | 'switch.programmable.fill'
                                                                                                                                                                                                                                                                                                                        | 'switch.programmable.square'
                                                                                                                                                                                                                                                                                                                        | 'switch.programmable.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'syringe'
                                                                                                                                                                                                                                                                                                                        | 'syringe.fill'
                                                                                                                                                                                                                                                                                                                        | 't.bubble'
                                                                                                                                                                                                                                                                                                                        | 't.bubble.ar'
                                                                                                                                                                                                                                                                                                                        | 't.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 't.bubble.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 't.bubble.fill.he'
                                                                                                                                                                                                                                                                                                                        | 't.bubble.he'
                                                                                                                                                                                                                                                                                                                        | 't.circle'
                                                                                                                                                                                                                                                                                                                        | 't.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 't.square'
                                                                                                                                                                                                                                                                                                                        | 't.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'table'
                                                                                                                                                                                                                                                                                                                        | 'table.badge.more'
                                                                                                                                                                                                                                                                                                                        | 'table.badge.more.fill'
                                                                                                                                                                                                                                                                                                                        | 'table.fill'
                                                                                                                                                                                                                                                                                                                        | 'table.furniture'
                                                                                                                                                                                                                                                                                                                        | 'table.furniture.fill'
                                                                                                                                                                                                                                                                                                                        | 'tablecells'
                                                                                                                                                                                                                                                                                                                        | 'tablecells.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'tablecells.badge.ellipsis.fill'
                                                                                                                                                                                                                                                                                                                        | 'tablecells.fill'
                                                                                                                                                                                                                                                                                                                        | 'tablecells.fill.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'tachometer'
                                                                                                                                                                                                                                                                                                                        | 'tag'
                                                                                                                                                                                                                                                                                                                        | 'tag.circle'
                                                                                                                                                                                                                                                                                                                        | 'tag.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tag.fill'
                                                                                                                                                                                                                                                                                                                        | 'tag.slash'
                                                                                                                                                                                                                                                                                                                        | 'tag.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'tag.square'
                                                                                                                                                                                                                                                                                                                        | 'tag.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'taillight.fog'
                                                                                                                                                                                                                                                                                                                        | 'taillight.fog.fill'
                                                                                                                                                                                                                                                                                                                        | 'takeoutbag.and.cup.and.straw'
                                                                                                                                                                                                                                                                                                                        | 'takeoutbag.and.cup.and.straw.fill'
                                                                                                                                                                                                                                                                                                                        | 'target'
                                                                                                                                                                                                                                                                                                                        | 'teddybear'
                                                                                                                                                                                                                                                                                                                        | 'teddybear.fill'
                                                                                                                                                                                                                                                                                                                        | 'teletype'
                                                                                                                                                                                                                                                                                                                        | 'teletype.answer'
                                                                                                                                                                                                                                                                                                                        | 'teletype.answer.circle'
                                                                                                                                                                                                                                                                                                                        | 'teletype.answer.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'teletype.circle'
                                                                                                                                                                                                                                                                                                                        | 'teletype.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tengesign'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.circle'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.ring'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.square'
                                                                                                                                                                                                                                                                                                                        | 'tengesign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'tennis.racket'
                                                                                                                                                                                                                                                                                                                        | 'tennis.racket.circle'
                                                                                                                                                                                                                                                                                                                        | 'tennis.racket.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tennisball'
                                                                                                                                                                                                                                                                                                                        | 'tennisball.circle'
                                                                                                                                                                                                                                                                                                                        | 'tennisball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tennisball.fill'
                                                                                                                                                                                                                                                                                                                        | 'tent'
                                                                                                                                                                                                                                                                                                                        | 'tent.2'
                                                                                                                                                                                                                                                                                                                        | 'tent.2.circle'
                                                                                                                                                                                                                                                                                                                        | 'tent.2.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tent.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'tent.circle'
                                                                                                                                                                                                                                                                                                                        | 'tent.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tent.fill'
                                                                                                                                                                                                                                                                                                                        | 'terminal'
                                                                                                                                                                                                                                                                                                                        | 'terminal.fill'
                                                                                                                                                                                                                                                                                                                        | 'testtube.2'
                                                                                                                                                                                                                                                                                                                        | 'text.aligncenter'
                                                                                                                                                                                                                                                                                                                        | 'text.alignleft'
                                                                                                                                                                                                                                                                                                                        | 'text.alignright'
                                                                                                                                                                                                                                                                                                                        | 'text.and.command.interface.window'
                                                                                                                                                                                                                                                                                                                        | 'text.and.command.macwindow'
                                                                                                                                                                                                                                                                                                                        | 'text.append'
                                                                                                                                                                                                                                                                                                                        | 'text.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'text.badge.checkmark.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'text.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'text.badge.star'
                                                                                                                                                                                                                                                                                                                        | 'text.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'text.below.folder'
                                                                                                                                                                                                                                                                                                                        | 'text.below.folder.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.below.photo'
                                                                                                                                                                                                                                                                                                                        | 'text.below.photo.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.below.photo.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.below.photo.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.book.closed'
                                                                                                                                                                                                                                                                                                                        | 'text.book.closed.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.badge.clock.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.badge.clock.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.badge.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.badge.sparkles.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.badge.sparkles.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.badge.sparkles.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.bubble.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.cursor'
                                                                                                                                                                                                                                                                                                                        | 'text.cursor.ar'
                                                                                                                                                                                                                                                                                                                        | 'text.cursor.he'
                                                                                                                                                                                                                                                                                                                        | 'text.cursor.hi'
                                                                                                                                                                                                                                                                                                                        | 'text.cursor.ja'
                                                                                                                                                                                                                                                                                                                        | 'text.cursor.ko'
                                                                                                                                                                                                                                                                                                                        | 'text.cursor.th'
                                                                                                                                                                                                                                                                                                                        | 'text.cursor.zh'
                                                                                                                                                                                                                                                                                                                        | 'text.document'
                                                                                                                                                                                                                                                                                                                        | 'text.document.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.insert'
                                                                                                                                                                                                                                                                                                                        | 'text.justify'
                                                                                                                                                                                                                                                                                                                        | 'text.justify.leading'
                                                                                                                                                                                                                                                                                                                        | 'text.justify.left'
                                                                                                                                                                                                                                                                                                                        | 'text.justify.right'
                                                                                                                                                                                                                                                                                                                        | 'text.justify.trailing'
                                                                                                                                                                                                                                                                                                                        | 'text.justifyleft'
                                                                                                                                                                                                                                                                                                                        | 'text.justifyright'
                                                                                                                                                                                                                                                                                                                        | 'text.line.2.summary'
                                                                                                                                                                                                                                                                                                                        | 'text.line.2.summary.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'text.line.3.summary'
                                                                                                                                                                                                                                                                                                                        | 'text.line.first.and.arrowtriangle.forward'
                                                                                                                                                                                                                                                                                                                        | 'text.line.last.and.arrowtriangle.forward'
                                                                                                                                                                                                                                                                                                                        | 'text.line.magnify'
                                                                                                                                                                                                                                                                                                                        | 'text.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'text.magnifyingglass.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.menu'
                                                                                                                                                                                                                                                                                                                        | 'text.pad.header'
                                                                                                                                                                                                                                                                                                                        | 'text.pad.header.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'text.pad.header.badge.clock.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.pad.header.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'text.page'
                                                                                                                                                                                                                                                                                                                        | 'text.page.and.line.vertical.and.text.page'
                                                                                                                                                                                                                                                                                                                        | 'text.page.and.line.vertical.and.text.page.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.page.badge.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'text.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.page.slash'
                                                                                                                                                                                                                                                                                                                        | 'text.page.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.page.slash.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.page.slash.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.quote'
                                                                                                                                                                                                                                                                                                                        | 'text.quote.rtl'
                                                                                                                                                                                                                                                                                                                        | 'text.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'text.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.rectangle.page'
                                                                                                                                                                                                                                                                                                                        | 'text.rectangle.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'text.redaction'
                                                                                                                                                                                                                                                                                                                        | 'text.square.filled'
                                                                                                                                                                                                                                                                                                                        | 'text.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'text.word.spacing'
                                                                                                                                                                                                                                                                                                                        | 'textbox'
                                                                                                                                                                                                                                                                                                                        | 'textbox.ar'
                                                                                                                                                                                                                                                                                                                        | 'textbox.he'
                                                                                                                                                                                                                                                                                                                        | 'textbox.hi'
                                                                                                                                                                                                                                                                                                                        | 'textbox.ja'
                                                                                                                                                                                                                                                                                                                        | 'textbox.ko'
                                                                                                                                                                                                                                                                                                                        | 'textbox.th'
                                                                                                                                                                                                                                                                                                                        | 'textbox.zh'
                                                                                                                                                                                                                                                                                                                        | 'textformat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.12'
                                                                                                                                                                                                                                                                                                                        | 'textformat.12.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.12.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.12.km'
                                                                                                                                                                                                                                                                                                                        | 'textformat.12.my'
                                                                                                                                                                                                                                                                                                                        | 'textformat.123'
                                                                                                                                                                                                                                                                                                                        | 'textformat.123.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.123.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.abc'
                                                                                                                                                                                                                                                                                                                        | 'textformat.abc.dottedunderline'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.el'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.he'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.ja'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.ko'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.si'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.ta'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.th'
                                                                                                                                                                                                                                                                                                                        | 'textformat.alt.zh'
                                                                                                                                                                                                                                                                                                                        | 'textformat.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.el'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.he'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.ja'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.ko'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.ru'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.si'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.ta'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.th'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.arrow.left.and.right.zh'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.el'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.he'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.ja'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.ko'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.ru'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.si'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.ta'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.th'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.dottedunderline.zh'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.el'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.he'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.ja'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.ko'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.ru'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.si'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.ta'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.th'
                                                                                                                                                                                                                                                                                                                        | 'textformat.characters.zh'
                                                                                                                                                                                                                                                                                                                        | 'textformat.el'
                                                                                                                                                                                                                                                                                                                        | 'textformat.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.he'
                                                                                                                                                                                                                                                                                                                        | 'textformat.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.ja'
                                                                                                                                                                                                                                                                                                                        | 'textformat.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.ko'
                                                                                                                                                                                                                                                                                                                        | 'textformat.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.km'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.my'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.numbers.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.si'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.he'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.ja'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.ko'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.he'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.ja'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.ko'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.si'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.ta'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.th'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.larger.zh'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.si'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.he'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.ja'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.ko'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.si'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.ta'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.th'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.smaller.zh'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.ta'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.th'
                                                                                                                                                                                                                                                                                                                        | 'textformat.size.zh'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.he'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.ja'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.ko'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.si'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.ta'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.th'
                                                                                                                                                                                                                                                                                                                        | 'textformat.subscript.zh'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.ar'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.bn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.gu'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.he'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.hi'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.ja'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.kn'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.ko'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.ml'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.mni'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.mr'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.or'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.pa'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.sat'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.si'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.ta'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.th'
                                                                                                                                                                                                                                                                                                                        | 'textformat.superscript.zh'
                                                                                                                                                                                                                                                                                                                        | 'textformat.ta'
                                                                                                                                                                                                                                                                                                                        | 'textformat.te'
                                                                                                                                                                                                                                                                                                                        | 'textformat.th'
                                                                                                                                                                                                                                                                                                                        | 'textformat.zh'
                                                                                                                                                                                                                                                                                                                        | 'theatermask.and.paintbrush'
                                                                                                                                                                                                                                                                                                                        | 'theatermask.and.paintbrush.fill'
                                                                                                                                                                                                                                                                                                                        | 'theatermasks'
                                                                                                                                                                                                                                                                                                                        | 'theatermasks.circle'
                                                                                                                                                                                                                                                                                                                        | 'theatermasks.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'theatermasks.fill'
                                                                                                                                                                                                                                                                                                                        | 'thermometer'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.and.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.and.liquid.waves'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.and.liquid.waves.snowflake'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.and.liquid.waves.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.brakesignal'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.gauge.open'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.high'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.low'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.medium'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.medium.slash'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.snowflake'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.snowflake.circle'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.snowflake.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.sun'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.sun.circle'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.sun.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.sun.fill'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.tirepressure'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.transmission'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.variable'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.variable.and.figure'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.variable.and.figure.circle'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.variable.and.figure.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.variable.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'thermometer.variable.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'ticket'
                                                                                                                                                                                                                                                                                                                        | 'ticket.circle'
                                                                                                                                                                                                                                                                                                                        | 'ticket.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'ticket.fill'
                                                                                                                                                                                                                                                                                                                        | 'timelapse'
                                                                                                                                                                                                                                                                                                                        | 'timeline.selection'
                                                                                                                                                                                                                                                                                                                        | 'timer'
                                                                                                                                                                                                                                                                                                                        | 'timer.circle'
                                                                                                                                                                                                                                                                                                                        | 'timer.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'timer.square'
                                                                                                                                                                                                                                                                                                                        | 'tire'
                                                                                                                                                                                                                                                                                                                        | 'tire.badge.snowflake'
                                                                                                                                                                                                                                                                                                                        | 'tirepressure'
                                                                                                                                                                                                                                                                                                                        | 'togglepower'
                                                                                                                                                                                                                                                                                                                        | 'toilet'
                                                                                                                                                                                                                                                                                                                        | 'toilet.circle'
                                                                                                                                                                                                                                                                                                                        | 'toilet.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'toilet.fill'
                                                                                                                                                                                                                                                                                                                        | 'tornado'
                                                                                                                                                                                                                                                                                                                        | 'tornado.circle'
                                                                                                                                                                                                                                                                                                                        | 'tornado.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tortoise'
                                                                                                                                                                                                                                                                                                                        | 'tortoise.circle'
                                                                                                                                                                                                                                                                                                                        | 'tortoise.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tortoise.fill'
                                                                                                                                                                                                                                                                                                                        | 'torus'
                                                                                                                                                                                                                                                                                                                        | 'touchid'
                                                                                                                                                                                                                                                                                                                        | 'tow.hitch'
                                                                                                                                                                                                                                                                                                                        | 'tow.hitch.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'tow.hitch.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'tow.hitch.fill'
                                                                                                                                                                                                                                                                                                                        | 'traction.control.tirepressure'
                                                                                                                                                                                                                                                                                                                        | 'traction.control.tirepressure.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'traction.control.tirepressure.slash'
                                                                                                                                                                                                                                                                                                                        | 'train.side.front.car'
                                                                                                                                                                                                                                                                                                                        | 'train.side.middle.car'
                                                                                                                                                                                                                                                                                                                        | 'train.side.rear.car'
                                                                                                                                                                                                                                                                                                                        | 'tram'
                                                                                                                                                                                                                                                                                                                        | 'tram.card'
                                                                                                                                                                                                                                                                                                                        | 'tram.card.fill'
                                                                                                                                                                                                                                                                                                                        | 'tram.circle'
                                                                                                                                                                                                                                                                                                                        | 'tram.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tram.fill'
                                                                                                                                                                                                                                                                                                                        | 'tram.fill.tunnel'
                                                                                                                                                                                                                                                                                                                        | 'tram.tunnel.fill'
                                                                                                                                                                                                                                                                                                                        | 'translate'
                                                                                                                                                                                                                                                                                                                        | 'transmission'
                                                                                                                                                                                                                                                                                                                        | 'trapezoid.and.line.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'trapezoid.and.line.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'trapezoid.and.line.vertical'
                                                                                                                                                                                                                                                                                                                        | 'trapezoid.and.line.vertical.fill'
                                                                                                                                                                                                                                                                                                                        | 'trash'
                                                                                                                                                                                                                                                                                                                        | 'trash.circle'
                                                                                                                                                                                                                                                                                                                        | 'trash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'trash.fill'
                                                                                                                                                                                                                                                                                                                        | 'trash.slash'
                                                                                                                                                                                                                                                                                                                        | 'trash.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'trash.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'trash.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'trash.slash.square'
                                                                                                                                                                                                                                                                                                                        | 'trash.slash.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'trash.square'
                                                                                                                                                                                                                                                                                                                        | 'trash.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'tray'
                                                                                                                                                                                                                                                                                                                        | 'tray.2'
                                                                                                                                                                                                                                                                                                                        | 'tray.2.fill'
                                                                                                                                                                                                                                                                                                                        | 'tray.and.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'tray.and.arrow.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'tray.and.arrow.up'
                                                                                                                                                                                                                                                                                                                        | 'tray.and.arrow.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'tray.badge'
                                                                                                                                                                                                                                                                                                                        | 'tray.badge.fill'
                                                                                                                                                                                                                                                                                                                        | 'tray.circle'
                                                                                                                                                                                                                                                                                                                        | 'tray.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tray.fill'
                                                                                                                                                                                                                                                                                                                        | 'tray.full'
                                                                                                                                                                                                                                                                                                                        | 'tray.full.fill'
                                                                                                                                                                                                                                                                                                                        | 'tree'
                                                                                                                                                                                                                                                                                                                        | 'tree.circle'
                                                                                                                                                                                                                                                                                                                        | 'tree.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tree.fill'
                                                                                                                                                                                                                                                                                                                        | 'triangle'
                                                                                                                                                                                                                                                                                                                        | 'triangle.bottomhalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'triangle.circle'
                                                                                                                                                                                                                                                                                                                        | 'triangle.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'triangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'triangle.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'triangle.lefthalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'triangle.lefthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'triangle.righthalf.fill'
                                                                                                                                                                                                                                                                                                                        | 'triangle.righthalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'triangle.tophalf.filled'
                                                                                                                                                                                                                                                                                                                        | 'triangleshape'
                                                                                                                                                                                                                                                                                                                        | 'triangleshape.fill'
                                                                                                                                                                                                                                                                                                                        | 'trophy'
                                                                                                                                                                                                                                                                                                                        | 'trophy.circle'
                                                                                                                                                                                                                                                                                                                        | 'trophy.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'trophy.fill'
                                                                                                                                                                                                                                                                                                                        | 'tropicalstorm'
                                                                                                                                                                                                                                                                                                                        | 'tropicalstorm.circle'
                                                                                                                                                                                                                                                                                                                        | 'tropicalstorm.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.box'
                                                                                                                                                                                                                                                                                                                        | 'truck.box.badge.clock'
                                                                                                                                                                                                                                                                                                                        | 'truck.box.badge.clock.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.box.badge.clock.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'truck.box.badge.clock.rtl'
                                                                                                                                                                                                                                                                                                                        | 'truck.box.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.air.circulate'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.air.circulate.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.air.fresh'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.air.fresh.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.and.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.and.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.arrow.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.arrow.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.arrowtriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.arrowtriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.arrowtriangle.up'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.arrowtriangle.up.arrowtriangle.down'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.arrowtriangle.up.arrowtriangle.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.arrowtriangle.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.front.open'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.front.open.crop'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.front.open.crop.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.front.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.hill.down'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.hill.down.and.gauge.open.with.lines.needle.25percent.and.arrowtriangle'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.hill.down.and.gauge.open.with.lines.needle.25percent.and.arrowtriangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.hill.down.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.hill.up'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.hill.up.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.lock'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.lock.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.lock.open'
                                                                                                                                                                                                                                                                                                                        | 'truck.pickup.side.lock.open.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.side.hill.descent.control'
                                                                                                                                                                                                                                                                                                                        | 'truck.side.hill.descent.control.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.side.roof.cargo.carrier'
                                                                                                                                                                                                                                                                                                                        | 'truck.side.roof.cargo.carrier.fill'
                                                                                                                                                                                                                                                                                                                        | 'truck.side.roof.cargo.carrier.slash'
                                                                                                                                                                                                                                                                                                                        | 'truck.side.roof.cargo.carrier.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'tsa'
                                                                                                                                                                                                                                                                                                                        | 'tsa.circle'
                                                                                                                                                                                                                                                                                                                        | 'tsa.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tsa.slash'
                                                                                                                                                                                                                                                                                                                        | 'tshirt'
                                                                                                                                                                                                                                                                                                                        | 'tshirt.circle'
                                                                                                                                                                                                                                                                                                                        | 'tshirt.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tshirt.fill'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.circle'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.ring'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.square'
                                                                                                                                                                                                                                                                                                                        | 'tugriksign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'tuningfork'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.circle'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.ring'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.square'
                                                                                                                                                                                                                                                                                                                        | 'turkishlirasign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'tv'
                                                                                                                                                                                                                                                                                                                        | 'tv.and.hifispeaker.fill'
                                                                                                                                                                                                                                                                                                                        | 'tv.and.mediabox'
                                                                                                                                                                                                                                                                                                                        | 'tv.and.mediabox.fill'
                                                                                                                                                                                                                                                                                                                        | 'tv.badge.wifi'
                                                                                                                                                                                                                                                                                                                        | 'tv.badge.wifi.fill'
                                                                                                                                                                                                                                                                                                                        | 'tv.circle'
                                                                                                                                                                                                                                                                                                                        | 'tv.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'tv.fill'
                                                                                                                                                                                                                                                                                                                        | 'tv.inset.filled'
                                                                                                                                                                                                                                                                                                                        | 'tv.music.note'
                                                                                                                                                                                                                                                                                                                        | 'tv.music.note.fill'
                                                                                                                                                                                                                                                                                                                        | 'tv.slash'
                                                                                                                                                                                                                                                                                                                        | 'tv.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'u.circle'
                                                                                                                                                                                                                                                                                                                        | 'u.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'u.square'
                                                                                                                                                                                                                                                                                                                        | 'u.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'uiwindow.split.2x1'
                                                                                                                                                                                                                                                                                                                        | 'umbrella'
                                                                                                                                                                                                                                                                                                                        | 'umbrella.circle'
                                                                                                                                                                                                                                                                                                                        | 'umbrella.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'umbrella.fill'
                                                                                                                                                                                                                                                                                                                        | 'umbrella.gauge.open'
                                                                                                                                                                                                                                                                                                                        | 'umbrella.percent'
                                                                                                                                                                                                                                                                                                                        | 'umbrella.percent.ar'
                                                                                                                                                                                                                                                                                                                        | 'umbrella.percent.fill'
                                                                                                                                                                                                                                                                                                                        | 'umbrella.percent.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'umbrella.sensor.tag.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'umbrella.sensor.tag.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'underline'
                                                                                                                                                                                                                                                                                                                        | 'underline.double'
                                                                                                                                                                                                                                                                                                                        | 'v.circle'
                                                                                                                                                                                                                                                                                                                        | 'v.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'v.square'
                                                                                                                                                                                                                                                                                                                        | 'v.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'vent.airflow.diffused'
                                                                                                                                                                                                                                                                                                                        | 'vent.airflow.focused'
                                                                                                                                                                                                                                                                                                                        | 'vent.airflow.manual'
                                                                                                                                                                                                                                                                                                                        | 'vent.airflow.oscillating'
                                                                                                                                                                                                                                                                                                                        | 'vent.heat.waves.upward'
                                                                                                                                                                                                                                                                                                                        | 'vial.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'video'
                                                                                                                                                                                                                                                                                                                        | 'video.and.waveform'
                                                                                                                                                                                                                                                                                                                        | 'video.and.waveform.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.plus.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.questionmark'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.questionmark.ar'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.questionmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.questionmark.fill.ar'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.shield.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.shield.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.waveform'
                                                                                                                                                                                                                                                                                                                        | 'video.badge.waveform.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.bubble'
                                                                                                                                                                                                                                                                                                                        | 'video.bubble.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.bubble.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'video.bubble.left'
                                                                                                                                                                                                                                                                                                                        | 'video.bubble.left.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.bubble.rtl'
                                                                                                                                                                                                                                                                                                                        | 'video.circle'
                                                                                                                                                                                                                                                                                                                        | 'video.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.doorbell'
                                                                                                                                                                                                                                                                                                                        | 'video.doorbell.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.fill.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'video.fill.badge.ellipsis'
                                                                                                                                                                                                                                                                                                                        | 'video.fill.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'video.slash'
                                                                                                                                                                                                                                                                                                                        | 'video.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'video.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'video.square'
                                                                                                                                                                                                                                                                                                                        | 'video.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'videoprojector'
                                                                                                                                                                                                                                                                                                                        | 'videoprojector.fill'
                                                                                                                                                                                                                                                                                                                        | 'view.2d'
                                                                                                                                                                                                                                                                                                                        | 'view.3d'
                                                                                                                                                                                                                                                                                                                        | 'viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'viewfinder.and.person'
                                                                                                                                                                                                                                                                                                                        | 'viewfinder.circle'
                                                                                                                                                                                                                                                                                                                        | 'viewfinder.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'viewfinder.rectangular'
                                                                                                                                                                                                                                                                                                                        | 'viewfinder.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.and.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.and.arrow.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.badge.checkmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.badge.play.fill'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.circle'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.fill'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.slash'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'vision.pro.trianglebadge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'visionpro'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.and.arrow.forward'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.and.arrow.forward.fill'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.badge.exclamationmark.fill'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.badge.play'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.badge.play.fill'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.circle'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.fill'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.slash'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.slash.circle'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.slash.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'visionpro.slash.fill'
                                                                                                                                                                                                                                                                                                                        | 'voiceover'
                                                                                                                                                                                                                                                                                                                        | 'volleyball'
                                                                                                                                                                                                                                                                                                                        | 'volleyball.circle'
                                                                                                                                                                                                                                                                                                                        | 'volleyball.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'volleyball.fill'
                                                                                                                                                                                                                                                                                                                        | 'w.circle'
                                                                                                                                                                                                                                                                                                                        | 'w.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'w.square'
                                                                                                                                                                                                                                                                                                                        | 'w.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'wake'
                                                                                                                                                                                                                                                                                                                        | 'wake.circle'
                                                                                                                                                                                                                                                                                                                        | 'wake.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wallet.bifold'
                                                                                                                                                                                                                                                                                                                        | 'wallet.bifold.fill'
                                                                                                                                                                                                                                                                                                                        | 'wallet.pass'
                                                                                                                                                                                                                                                                                                                        | 'wallet.pass.fill'
                                                                                                                                                                                                                                                                                                                        | 'wallet.sensor.tag.radiowaves.left.and.right'
                                                                                                                                                                                                                                                                                                                        | 'wallet.sensor.tag.radiowaves.left.and.right.fill'
                                                                                                                                                                                                                                                                                                                        | 'wand.and.outline'
                                                                                                                                                                                                                                                                                                                        | 'wand.and.outline.inverse'
                                                                                                                                                                                                                                                                                                                        | 'wand.and.rays'
                                                                                                                                                                                                                                                                                                                        | 'wand.and.rays.inverse'
                                                                                                                                                                                                                                                                                                                        | 'wand.and.sparkles'
                                                                                                                                                                                                                                                                                                                        | 'wand.and.sparkles.inverse'
                                                                                                                                                                                                                                                                                                                        | 'wand.and.stars'
                                                                                                                                                                                                                                                                                                                        | 'wand.and.stars.inverse'
                                                                                                                                                                                                                                                                                                                        | 'warninglight'
                                                                                                                                                                                                                                                                                                                        | 'warninglight.fill'
                                                                                                                                                                                                                                                                                                                        | 'washer'
                                                                                                                                                                                                                                                                                                                        | 'washer.circle'
                                                                                                                                                                                                                                                                                                                        | 'washer.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'washer.fill'
                                                                                                                                                                                                                                                                                                                        | 'watch.analog'
                                                                                                                                                                                                                                                                                                                        | 'watchface.applewatch.case'
                                                                                                                                                                                                                                                                                                                        | 'water.waves'
                                                                                                                                                                                                                                                                                                                        | 'water.waves.and.arrow.down'
                                                                                                                                                                                                                                                                                                                        | 'water.waves.and.arrow.down.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'water.waves.and.arrow.trianglehead.down'
                                                                                                                                                                                                                                                                                                                        | 'water.waves.and.arrow.trianglehead.down.trianglebadge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'water.waves.and.arrow.trianglehead.up'
                                                                                                                                                                                                                                                                                                                        | 'water.waves.and.arrow.up'
                                                                                                                                                                                                                                                                                                                        | 'water.waves.slash'
                                                                                                                                                                                                                                                                                                                        | 'waterbottle'
                                                                                                                                                                                                                                                                                                                        | 'waterbottle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.backward'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.backward.circle'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.backward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down.car.side'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down.car.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down.circle'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down.convertible.side'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down.convertible.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down.pickup.side'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down.pickup.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down.suv.side'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.down.suv.side.fill'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.forward'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.forward.circle'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.forward.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.left'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.left.circle'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.left.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.right'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.right.circle'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.right.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.up'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.up.circle'
                                                                                                                                                                                                                                                                                                                        | 'wave.3.up.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'waveform'
                                                                                                                                                                                                                                                                                                                        | 'waveform.and.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'waveform.and.mic'
                                                                                                                                                                                                                                                                                                                        | 'waveform.and.person'
                                                                                                                                                                                                                                                                                                                        | 'waveform.and.person.filled'
                                                                                                                                                                                                                                                                                                                        | 'waveform.badge.checkmark'
                                                                                                                                                                                                                                                                                                                        | 'waveform.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'waveform.badge.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'waveform.badge.mic'
                                                                                                                                                                                                                                                                                                                        | 'waveform.badge.microphone'
                                                                                                                                                                                                                                                                                                                        | 'waveform.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'waveform.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'waveform.badge.xmark'
                                                                                                                                                                                                                                                                                                                        | 'waveform.circle'
                                                                                                                                                                                                                                                                                                                        | 'waveform.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'waveform.low'
                                                                                                                                                                                                                                                                                                                        | 'waveform.mid'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.badge.minus'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.magnifyingglass'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.text'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.text.clipboard'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.text.clipboard.fill'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.text.clipboard.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.text.clipboard.rtl'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.text.page'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.text.page.fill'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.text.page.fill.rtl'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.text.page.rtl'
                                                                                                                                                                                                                                                                                                                        | 'waveform.path.ecg.text.rtl'
                                                                                                                                                                                                                                                                                                                        | 'waveform.slash'
                                                                                                                                                                                                                                                                                                                        | 'web.camera'
                                                                                                                                                                                                                                                                                                                        | 'web.camera.fill'
                                                                                                                                                                                                                                                                                                                        | 'wheelchair'
                                                                                                                                                                                                                                                                                                                        | 'widget.extralarge'
                                                                                                                                                                                                                                                                                                                        | 'widget.extralarge.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'widget.grid.2x1.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'widget.grid.2x1.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'widget.large'
                                                                                                                                                                                                                                                                                                                        | 'widget.large.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'widget.medium'
                                                                                                                                                                                                                                                                                                                        | 'widget.medium.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'widget.small'
                                                                                                                                                                                                                                                                                                                        | 'widget.small.badge.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'widget.small.badge.plus'
                                                                                                                                                                                                                                                                                                                        | 'wifi'
                                                                                                                                                                                                                                                                                                                        | 'wifi.badge.lock'
                                                                                                                                                                                                                                                                                                                        | 'wifi.circle'
                                                                                                                                                                                                                                                                                                                        | 'wifi.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wifi.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'wifi.exclamationmark.circle'
                                                                                                                                                                                                                                                                                                                        | 'wifi.exclamationmark.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wifi.router'
                                                                                                                                                                                                                                                                                                                        | 'wifi.router.fill'
                                                                                                                                                                                                                                                                                                                        | 'wifi.slash'
                                                                                                                                                                                                                                                                                                                        | 'wifi.square'
                                                                                                                                                                                                                                                                                                                        | 'wifi.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'wind'
                                                                                                                                                                                                                                                                                                                        | 'wind.circle'
                                                                                                                                                                                                                                                                                                                        | 'wind.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wind.snow'
                                                                                                                                                                                                                                                                                                                        | 'wind.snow.circle'
                                                                                                                                                                                                                                                                                                                        | 'wind.snow.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'window.awning'
                                                                                                                                                                                                                                                                                                                        | 'window.awning.closed'
                                                                                                                                                                                                                                                                                                                        | 'window.casement'
                                                                                                                                                                                                                                                                                                                        | 'window.casement.closed'
                                                                                                                                                                                                                                                                                                                        | 'window.ceiling'
                                                                                                                                                                                                                                                                                                                        | 'window.ceiling.closed'
                                                                                                                                                                                                                                                                                                                        | 'window.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'window.horizontal.closed'
                                                                                                                                                                                                                                                                                                                        | 'window.shade.closed'
                                                                                                                                                                                                                                                                                                                        | 'window.shade.open'
                                                                                                                                                                                                                                                                                                                        | 'window.vertical.closed'
                                                                                                                                                                                                                                                                                                                        | 'window.vertical.open'
                                                                                                                                                                                                                                                                                                                        | 'windshield.front.and.fluid'
                                                                                                                                                                                                                                                                                                                        | 'windshield.front.and.fluid.and.spray'
                                                                                                                                                                                                                                                                                                                        | 'windshield.front.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'windshield.front.and.spray'
                                                                                                                                                                                                                                                                                                                        | 'windshield.front.and.wiper'
                                                                                                                                                                                                                                                                                                                        | 'windshield.front.and.wiper.and.drop'
                                                                                                                                                                                                                                                                                                                        | 'windshield.front.and.wiper.and.spray'
                                                                                                                                                                                                                                                                                                                        | 'windshield.front.and.wiper.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'windshield.front.and.wiper.intermittent'
                                                                                                                                                                                                                                                                                                                        | 'windshield.rear.and.fluid'
                                                                                                                                                                                                                                                                                                                        | 'windshield.rear.and.fluid.and.spray'
                                                                                                                                                                                                                                                                                                                        | 'windshield.rear.and.heat.waves'
                                                                                                                                                                                                                                                                                                                        | 'windshield.rear.and.spray'
                                                                                                                                                                                                                                                                                                                        | 'windshield.rear.and.wiper'
                                                                                                                                                                                                                                                                                                                        | 'windshield.rear.and.wiper.and.drop'
                                                                                                                                                                                                                                                                                                                        | 'windshield.rear.and.wiper.and.spray'
                                                                                                                                                                                                                                                                                                                        | 'windshield.rear.and.wiper.exclamationmark'
                                                                                                                                                                                                                                                                                                                        | 'windshield.rear.and.wiper.intermittent'
                                                                                                                                                                                                                                                                                                                        | 'wineglass'
                                                                                                                                                                                                                                                                                                                        | 'wineglass.fill'
                                                                                                                                                                                                                                                                                                                        | 'wonsign'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.circle'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.ring'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.square'
                                                                                                                                                                                                                                                                                                                        | 'wonsign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'wrench'
                                                                                                                                                                                                                                                                                                                        | 'wrench.adjustable'
                                                                                                                                                                                                                                                                                                                        | 'wrench.adjustable.fill'
                                                                                                                                                                                                                                                                                                                        | 'wrench.and.screwdriver'
                                                                                                                                                                                                                                                                                                                        | 'wrench.and.screwdriver.fill'
                                                                                                                                                                                                                                                                                                                        | 'wrench.fill'
                                                                                                                                                                                                                                                                                                                        | 'wrongwaysign'
                                                                                                                                                                                                                                                                                                                        | 'wrongwaysign.fill'
                                                                                                                                                                                                                                                                                                                        | 'x.circle'
                                                                                                                                                                                                                                                                                                                        | 'x.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'x.square'
                                                                                                                                                                                                                                                                                                                        | 'x.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'x.squareroot'
                                                                                                                                                                                                                                                                                                                        | 'xbox.logo'
                                                                                                                                                                                                                                                                                                                        | 'xmark'
                                                                                                                                                                                                                                                                                                                        | 'xmark.app'
                                                                                                                                                                                                                                                                                                                        | 'xmark.app.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.bin'
                                                                                                                                                                                                                                                                                                                        | 'xmark.bin.circle'
                                                                                                                                                                                                                                                                                                                        | 'xmark.bin.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.bin.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.circle'
                                                                                                                                                                                                                                                                                                                        | 'xmark.circle.badge.airplane'
                                                                                                                                                                                                                                                                                                                        | 'xmark.circle.badge.airplane.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.diamond'
                                                                                                                                                                                                                                                                                                                        | 'xmark.diamond.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.icloud'
                                                                                                                                                                                                                                                                                                                        | 'xmark.icloud.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.interface.window'
                                                                                                                                                                                                                                                                                                                        | 'xmark.octagon'
                                                                                                                                                                                                                                                                                                                        | 'xmark.octagon.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.rectangle'
                                                                                                                                                                                                                                                                                                                        | 'xmark.rectangle.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.rectangle.portrait'
                                                                                                                                                                                                                                                                                                                        | 'xmark.rectangle.portrait.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.seal'
                                                                                                                                                                                                                                                                                                                        | 'xmark.seal.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.shield'
                                                                                                                                                                                                                                                                                                                        | 'xmark.shield.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.square'
                                                                                                                                                                                                                                                                                                                        | 'xmark.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.triangle.circle.square'
                                                                                                                                                                                                                                                                                                                        | 'xmark.triangle.circle.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'xmark.viewfinder'
                                                                                                                                                                                                                                                                                                                        | 'xserve'
                                                                                                                                                                                                                                                                                                                        | 'xserve.raid'
                                                                                                                                                                                                                                                                                                                        | 'y.circle'
                                                                                                                                                                                                                                                                                                                        | 'y.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'y.square'
                                                                                                                                                                                                                                                                                                                        | 'y.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'yensign'
                                                                                                                                                                                                                                                                                                                        | 'yensign.arrow.circlepath'
                                                                                                                                                                                                                                                                                                                        | 'yensign.arrow.trianglehead.counterclockwise.rotate.90'
                                                                                                                                                                                                                                                                                                                        | 'yensign.bank.building'
                                                                                                                                                                                                                                                                                                                        | 'yensign.bank.building.fill'
                                                                                                                                                                                                                                                                                                                        | 'yensign.building.classical'
                                                                                                                                                                                                                                                                                                                        | 'yensign.building.classical.fill'
                                                                                                                                                                                                                                                                                                                        | 'yensign.circle'
                                                                                                                                                                                                                                                                                                                        | 'yensign.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'yensign.gauge.chart.lefthalf.righthalf'
                                                                                                                                                                                                                                                                                                                        | 'yensign.gauge.chart.leftthird.topthird.rightthird'
                                                                                                                                                                                                                                                                                                                        | 'yensign.ring'
                                                                                                                                                                                                                                                                                                                        | 'yensign.ring.dashed'
                                                                                                                                                                                                                                                                                                                        | 'yensign.square'
                                                                                                                                                                                                                                                                                                                        | 'yensign.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'yieldsign'
                                                                                                                                                                                                                                                                                                                        | 'yieldsign.fill'
                                                                                                                                                                                                                                                                                                                        | 'z.circle'
                                                                                                                                                                                                                                                                                                                        | 'z.circle.fill'
                                                                                                                                                                                                                                                                                                                        | 'z.square'
                                                                                                                                                                                                                                                                                                                        | 'z.square.fill'
                                                                                                                                                                                                                                                                                                                        | 'zipper.page'
                                                                                                                                                                                                                                                                                                                        | 'zl.button.roundedtop.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'zl.button.roundedtop.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'zl.rectangle.roundedtop'
                                                                                                                                                                                                                                                                                                                        | 'zl.rectangle.roundedtop.fill'
                                                                                                                                                                                                                                                                                                                        | 'zr.button.roundedtop.horizontal'
                                                                                                                                                                                                                                                                                                                        | 'zr.button.roundedtop.horizontal.fill'
                                                                                                                                                                                                                                                                                                                        | 'zr.rectangle.roundedtop'
                                                                                                                                                                                                                                                                                                                        | 'zr.rectangle.roundedtop.fill'
                                                                                                                                                                                                                                                                                                                        | 'zzz';

                                                                                                                                                                                                                                                                                                                      type SheetPresentationOptions

                                                                                                                                                                                                                                                                                                                      type SheetPresentationOptions = {
                                                                                                                                                                                                                                                                                                                          sheetAllowedDetents?: number[] | 'fitToContents';
                                                                                                                                                                                                                                                                                                                          sheetGrabberVisible?: boolean;
                                                                                                                                                                                                                                                                                                                          sheetCornerRadius?: number;
                                                                                                                                                                                                                                                                                                                          sheetExpandsWhenScrolledToEdge?: boolean;
                                                                                                                                                                                                                                                                                                                          gestureEnabled?: boolean;
                                                                                                                                                                                                                                                                                                                          title?: string;
                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                        type SheetPresentationProps

                                                                                                                                                                                                                                                                                                                        type SheetPresentationProps = PresentationProps<SheetPresentationOptions>;

                                                                                                                                                                                                                                                                                                                          type SitemapType

                                                                                                                                                                                                                                                                                                                          type SitemapType = {
                                                                                                                                                                                                                                                                                                                              contextKey: string;
                                                                                                                                                                                                                                                                                                                              filename: string;
                                                                                                                                                                                                                                                                                                                              href: string | OneRouter.Href;
                                                                                                                                                                                                                                                                                                                              isInitial: boolean;
                                                                                                                                                                                                                                                                                                                              isInternal: boolean;
                                                                                                                                                                                                                                                                                                                              isGenerated: boolean;
                                                                                                                                                                                                                                                                                                                              children: SitemapType[];
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            type SuspenseFallbackProps

                                                                                                                                                                                                                                                                                                                            type SuspenseFallbackProps = {
                                                                                                                                                                                                                                                                                                                                /** The suspended route module's context key, such as `./profile/[id].tsx`. */
                                                                                                                                                                                                                                                                                                                                route: string;
                                                                                                                                                                                                                                                                                                                                /** The suspended route's URL parameters. */
                                                                                                                                                                                                                                                                                                                                params: Record<string, string | string[]>;
                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                            • Props passed to a layout's SuspenseFallback export.

                                                                                                                                                                                                                                                                                                                            type UnitPoint

                                                                                                                                                                                                                                                                                                                            type UnitPoint = UnitPointName | { x: number; y: number };

                                                                                                                                                                                                                                                                                                                              type UseDrawerResult

                                                                                                                                                                                                                                                                                                                              type UseDrawerResult = {
                                                                                                                                                                                                                                                                                                                                  screens: ScreenEntry[];
                                                                                                                                                                                                                                                                                                                                  focused: ScreenEntry;
                                                                                                                                                                                                                                                                                                                                  isOpen: boolean;
                                                                                                                                                                                                                                                                                                                                  open: () => void;
                                                                                                                                                                                                                                                                                                                                  close: () => void;
                                                                                                                                                                                                                                                                                                                                  toggle: () => void;
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                type UseFontsResult

                                                                                                                                                                                                                                                                                                                                type UseFontsResult = readonly [loaded: boolean, error: Error | null];

                                                                                                                                                                                                                                                                                                                                  type UserInterfaceSizeClass

                                                                                                                                                                                                                                                                                                                                  type UserInterfaceSizeClass = 'compact' | 'regular' | 'unspecified';

                                                                                                                                                                                                                                                                                                                                    type UseStackResult

                                                                                                                                                                                                                                                                                                                                    type UseStackResult = {
                                                                                                                                                                                                                                                                                                                                        screens: ScreenEntry[];
                                                                                                                                                                                                                                                                                                                                        focused: ScreenEntry;
                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                      type UseTabsResult

                                                                                                                                                                                                                                                                                                                                      type UseTabsResult = {
                                                                                                                                                                                                                                                                                                                                          screens: ScreenEntry[];
                                                                                                                                                                                                                                                                                                                                          focused: ScreenEntry;
                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                        type ValidateRouteProps

                                                                                                                                                                                                                                                                                                                                        type ValidateRouteProps = {
                                                                                                                                                                                                                                                                                                                                            params: Record<string, string | string[]>;
                                                                                                                                                                                                                                                                                                                                            search: Record<string, string | string[]>;
                                                                                                                                                                                                                                                                                                                                            pathname: string;
                                                                                                                                                                                                                                                                                                                                            href: string;
                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                        • Props passed to validateRoute function

                                                                                                                                                                                                                                                                                                                                        type ValidationResult

                                                                                                                                                                                                                                                                                                                                        type ValidationResult =
                                                                                                                                                                                                                                                                                                                                            | { valid: true }
                                                                                                                                                                                                                                                                                                                                            | { valid: false; error: string; details?: Record<string, unknown> };

                                                                                                                                                                                                                                                                                                                                        • Result from validateRoute function

                                                                                                                                                                                                                                                                                                                                        type ValidationState

                                                                                                                                                                                                                                                                                                                                        type ValidationState = {
                                                                                                                                                                                                                                                                                                                                            status: 'idle' | 'validating' | 'error' | 'valid';
                                                                                                                                                                                                                                                                                                                                            error?: Error;
                                                                                                                                                                                                                                                                                                                                            lastValidatedHref?: string;
                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                          type WebPresentations

                                                                                                                                                                                                                                                                                                                                          type WebPresentations = {
                                                                                                                                                                                                                                                                                                                                              sheet?: ComponentType<SheetPresentationProps>;
                                                                                                                                                                                                                                                                                                                                              modal?: ComponentType<ModalPresentationProps>;
                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                            type WorkerContext

                                                                                                                                                                                                                                                                                                                                            type WorkerContext = {
                                                                                                                                                                                                                                                                                                                                                env?: WorkerEnv;
                                                                                                                                                                                                                                                                                                                                                executionCtx?: WorkerExecutionContext;
                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                            • Worker-runtime context surfaced on API handlers when running under an edge runtime (Cloudflare Workers). Undefined in dev/Node.

                                                                                                                                                                                                                                                                                                                                            type WorkerEnv

                                                                                                                                                                                                                                                                                                                                            type WorkerEnv = Record<string, unknown>;

                                                                                                                                                                                                                                                                                                                                            • Cloudflare Workers env bindings. Shape is app-specific; unknown by default.

                                                                                                                                                                                                                                                                                                                                            type WorkerExecutionContext

                                                                                                                                                                                                                                                                                                                                            type WorkerExecutionContext = {
                                                                                                                                                                                                                                                                                                                                                waitUntil: (promise: Promise<unknown>) => void;
                                                                                                                                                                                                                                                                                                                                                passThroughOnException: () => void;
                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                            • Minimal shape of the Cloudflare Workers ExecutionContext. Use context.worker?.executionCtx?.waitUntil(promise) from an API handler to keep the worker alive for fire-and-forget background work after the response has been sent.

                                                                                                                                                                                                                                                                                                                                            Namespaces

                                                                                                                                                                                                                                                                                                                                            namespace *?imagedata

                                                                                                                                                                                                                                                                                                                                            module '*?imagedata' {}

                                                                                                                                                                                                                                                                                                                                              variable imageData

                                                                                                                                                                                                                                                                                                                                              const imageData: { src: string; width: number; height: number; blurDataURL: string };

                                                                                                                                                                                                                                                                                                                                                namespace client-only

                                                                                                                                                                                                                                                                                                                                                module 'client-only' {}

                                                                                                                                                                                                                                                                                                                                                  namespace native-only

                                                                                                                                                                                                                                                                                                                                                  module 'native-only' {}

                                                                                                                                                                                                                                                                                                                                                    namespace OneRouter

                                                                                                                                                                                                                                                                                                                                                    namespace OneRouter {}
                                                                                                                                                                                                                                                                                                                                                      const Link: LinkComponent;

                                                                                                                                                                                                                                                                                                                                                      • Component to render link to another route using a path. Uses an anchor tag on the web.

                                                                                                                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                                                                                                                        props.href Absolute path to route (e.g. `/feeds/hot`).

                                                                                                                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                                                                                                                        props.replace Should replace the current route without adding to the history.

                                                                                                                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                                                                                                                        props.asChild Forward props to child component. Useful for custom buttons.

                                                                                                                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                                                                                                                        props.children Child elements to render the content.

                                                                                                                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                                                                                                                        props.className On web, this sets the HTML `class` directly. On native, this can be used with CSS interop tools like Nativewind.

                                                                                                                                                                                                                                                                                                                                                      variable router

                                                                                                                                                                                                                                                                                                                                                      const router: Router;

                                                                                                                                                                                                                                                                                                                                                      • The imperative router.

                                                                                                                                                                                                                                                                                                                                                      function Redirect

                                                                                                                                                                                                                                                                                                                                                      Redirect: (props: React.PropsWithChildren<{ href: Href }>) => ReactNode;

                                                                                                                                                                                                                                                                                                                                                      • Redirects to the href as soon as the component is mounted.

                                                                                                                                                                                                                                                                                                                                                      function useActiveParams

                                                                                                                                                                                                                                                                                                                                                      useActiveParams: <
                                                                                                                                                                                                                                                                                                                                                          T extends string | UnknownOutputParams = UnknownOutputParams
                                                                                                                                                                                                                                                                                                                                                      >() => T extends AllRoutes ? SearchParams<T> : T;

                                                                                                                                                                                                                                                                                                                                                      • Get the globally selected query parameters, including dynamic path segments. This function will update even when the route is not focused. Useful for analytics or other background operations that don't draw to the screen.

                                                                                                                                                                                                                                                                                                                                                        When querying search params in a stack, opt-towards using `useParams` as these will only update when the route is focused.

                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                        • `useParams`

                                                                                                                                                                                                                                                                                                                                                      function useParams

                                                                                                                                                                                                                                                                                                                                                      useParams: <
                                                                                                                                                                                                                                                                                                                                                          TParams extends string | UnknownOutputParams = UnknownOutputParams
                                                                                                                                                                                                                                                                                                                                                      >() => TParams extends AllRoutes ? SearchParams<TParams> : TParams;

                                                                                                                                                                                                                                                                                                                                                      • Returns the URL search parameters for the contextually focused route. e.g. `/acme?foo=bar` -> `{ foo: "bar" }`. This is useful for stacks where you may push a new screen that changes the query parameters.

                                                                                                                                                                                                                                                                                                                                                        To observe updates even when the invoking route is not focused, use `useActiveParams()`.

                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                        • `useActiveParams`

                                                                                                                                                                                                                                                                                                                                                      function useRouter

                                                                                                                                                                                                                                                                                                                                                      useRouter: () => Router;

                                                                                                                                                                                                                                                                                                                                                      • Hooks

                                                                                                                                                                                                                                                                                                                                                      function useSegments

                                                                                                                                                                                                                                                                                                                                                      useSegments: <T extends string | [string]>() => T extends AbsoluteRoute
                                                                                                                                                                                                                                                                                                                                                          ? RouteSegments<T>
                                                                                                                                                                                                                                                                                                                                                          : T extends string
                                                                                                                                                                                                                                                                                                                                                          ? string[]
                                                                                                                                                                                                                                                                                                                                                          : T;

                                                                                                                                                                                                                                                                                                                                                      • Get a list of selected file segments for the currently selected route. Segments are not normalized, so they will be the same as the file path. e.g. /[id]?id=normal -> ["[id]"]

                                                                                                                                                                                                                                                                                                                                                        `useSegments` can be typed using an abstract. Consider the following file structure, and strictly typed `useSegments` function:

                                                                                                                                                                                                                                                                                                                                                        ```md - app - [user] - index.js - followers.js - settings.js ``` This can be strictly typed using the following abstract:

                                                                                                                                                                                                                                                                                                                                                        ```ts const [first, second] = useSegments<['settings'] | ['[user]'] | ['[user]', 'followers']>() ```

                                                                                                                                                                                                                                                                                                                                                      interface LinkComponent

                                                                                                                                                                                                                                                                                                                                                      interface LinkComponent {}

                                                                                                                                                                                                                                                                                                                                                        property resolveHref

                                                                                                                                                                                                                                                                                                                                                        resolveHref: (href: Href) => string;

                                                                                                                                                                                                                                                                                                                                                        • Helper method to resolve an Href object into a string.

                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                        <T extends string | object>(
                                                                                                                                                                                                                                                                                                                                                            props: React.PropsWithChildren<LinkProps<T>>
                                                                                                                                                                                                                                                                                                                                                        ): JSX.Element;

                                                                                                                                                                                                                                                                                                                                                          interface LinkProps

                                                                                                                                                                                                                                                                                                                                                          interface LinkProps<T extends string | object>
                                                                                                                                                                                                                                                                                                                                                              extends Omit<
                                                                                                                                                                                                                                                                                                                                                                      TextProps,
                                                                                                                                                                                                                                                                                                                                                                      'href' | 'disabled' | 'onLongPress' | 'onPressIn' | 'onPressOut'
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  Pick<
                                                                                                                                                                                                                                                                                                                                                                      PressableProps,
                                                                                                                                                                                                                                                                                                                                                                      'disabled' | 'onLongPress' | 'onPressIn' | 'onPressOut'
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  WebAnchorProps {}

                                                                                                                                                                                                                                                                                                                                                            property asChild

                                                                                                                                                                                                                                                                                                                                                            asChild?: boolean;

                                                                                                                                                                                                                                                                                                                                                            • Forward props to child component. Useful for custom buttons.

                                                                                                                                                                                                                                                                                                                                                            property className

                                                                                                                                                                                                                                                                                                                                                            className?: string;

                                                                                                                                                                                                                                                                                                                                                            • On web, this sets the HTML class directly. On native, this can be used with CSS interop tools like Nativewind.

                                                                                                                                                                                                                                                                                                                                                            property href

                                                                                                                                                                                                                                                                                                                                                            href: Href<T>;

                                                                                                                                                                                                                                                                                                                                                            • Path to route to.

                                                                                                                                                                                                                                                                                                                                                            property mask

                                                                                                                                                                                                                                                                                                                                                            mask?: Href<T>;

                                                                                                                                                                                                                                                                                                                                                            • Display a different URL in the browser than the actual route. Useful for modals and overlays that should show a clean URL.

                                                                                                                                                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                                                                                                                                                              <Link href="/photos/5/modal" mask="/photos/5">
                                                                                                                                                                                                                                                                                                                                                                View Photo
                                                                                                                                                                                                                                                                                                                                                              </Link>

                                                                                                                                                                                                                                                                                                                                                            property onPress

                                                                                                                                                                                                                                                                                                                                                            onPress?: (
                                                                                                                                                                                                                                                                                                                                                                e: React.MouseEvent<HTMLAnchorElement, MouseEvent> | GestureResponderEvent
                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                              property push

                                                                                                                                                                                                                                                                                                                                                              push?: boolean;

                                                                                                                                                                                                                                                                                                                                                              • Should push the current route

                                                                                                                                                                                                                                                                                                                                                              property replace

                                                                                                                                                                                                                                                                                                                                                              replace?: boolean;

                                                                                                                                                                                                                                                                                                                                                              • Should replace the current route without adding to the history.

                                                                                                                                                                                                                                                                                                                                                              interface WebAnchorProps

                                                                                                                                                                                                                                                                                                                                                              interface WebAnchorProps {}

                                                                                                                                                                                                                                                                                                                                                              • ********** * **********

                                                                                                                                                                                                                                                                                                                                                              property download

                                                                                                                                                                                                                                                                                                                                                              download?: string;

                                                                                                                                                                                                                                                                                                                                                              • **Web only:** Specifies that the href should be downloaded when the user clicks on the link, instead of navigating to it. It is typically used for links that point to files that the user should download, such as PDFs, images, documents, etc.

                                                                                                                                                                                                                                                                                                                                                                The value of the download property, which represents the filename for the downloaded file. This property is passed to the underlying anchor (<a>) tag.

                                                                                                                                                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                                                                                                                                                Download image

                                                                                                                                                                                                                                                                                                                                                              property rel

                                                                                                                                                                                                                                                                                                                                                              rel?: string;

                                                                                                                                                                                                                                                                                                                                                              • **Web only:** Specifies the relationship between the href and the current route.

                                                                                                                                                                                                                                                                                                                                                                Common values: - **nofollow**: Indicates to search engines that they should not follow the href. This is often used for user-generated content or links that should not influence search engine rankings. - **noopener**: Suggests that the href should not have access to the opening window's window.opener object, which is a security measure to prevent potentially harmful behavior in cases of links that open new tabs or windows. - **noreferrer**: Requests that the browser not send the Referer HTTP header when navigating to the href. This can enhance user privacy.

                                                                                                                                                                                                                                                                                                                                                                The rel property is primarily used for informational and instructive purposes, helping browsers and web crawlers make better decisions about how to handle and interpret the links on a web page. It is important to use appropriate rel values to ensure that links behave as intended and adhere to best practices for web development and SEO (Search Engine Optimization).

                                                                                                                                                                                                                                                                                                                                                                This property is passed to the underlying anchor (<a>) tag.

                                                                                                                                                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                                                                                                                                                Go to Expo

                                                                                                                                                                                                                                                                                                                                                              property target

                                                                                                                                                                                                                                                                                                                                                              target?: '_self' | '_blank' | '_parent' | '_top' | (string & object);

                                                                                                                                                                                                                                                                                                                                                              • **Web only:** Specifies where to open the href.

                                                                                                                                                                                                                                                                                                                                                                - **_self**: the current tab. - **_blank**: opens in a new tab or window. - **_parent**: opens in the parent browsing context. If no parent, defaults to **_self**. - **_top**: opens in the highest browsing context ancestor. If no ancestors, defaults to **_self**.

                                                                                                                                                                                                                                                                                                                                                                This property is passed to the underlying anchor (<a>) tag.

                                                                                                                                                                                                                                                                                                                                                                '_self'

                                                                                                                                                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                                                                                                                                                Go to Expo in new tab

                                                                                                                                                                                                                                                                                                                                                              type AbsoluteRoute

                                                                                                                                                                                                                                                                                                                                                              type AbsoluteRoute = DynamicRouteTemplate | StaticRoutes;

                                                                                                                                                                                                                                                                                                                                                                type AllRoutes

                                                                                                                                                                                                                                                                                                                                                                type AllRoutes = OneRouterRoutes | ExternalPathString;

                                                                                                                                                                                                                                                                                                                                                                  type CatchAllRoutePart

                                                                                                                                                                                                                                                                                                                                                                  type CatchAllRoutePart<S extends string> = S extends `${string}${SearchOrHash}`
                                                                                                                                                                                                                                                                                                                                                                      ? never
                                                                                                                                                                                                                                                                                                                                                                      : S extends ''
                                                                                                                                                                                                                                                                                                                                                                      ? never
                                                                                                                                                                                                                                                                                                                                                                      : S extends `${string}(${string})${string}`
                                                                                                                                                                                                                                                                                                                                                                      ? never
                                                                                                                                                                                                                                                                                                                                                                      : S extends `${string}[${string}]${string}`
                                                                                                                                                                                                                                                                                                                                                                      ? never
                                                                                                                                                                                                                                                                                                                                                                      : S;

                                                                                                                                                                                                                                                                                                                                                                  • Return only the CatchAll router part. If the string has search parameters or a hash return never

                                                                                                                                                                                                                                                                                                                                                                  type DynamicRoutesHref

                                                                                                                                                                                                                                                                                                                                                                  type DynamicRoutesHref = DynamicRouteString<
                                                                                                                                                                                                                                                                                                                                                                      { __branded__: any },
                                                                                                                                                                                                                                                                                                                                                                      DynamicRouteTemplate
                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                  • ******* Href * *******

                                                                                                                                                                                                                                                                                                                                                                  type DynamicRoutesHref2

                                                                                                                                                                                                                                                                                                                                                                  type DynamicRoutesHref2 = DynamicRouteString<string, DynamicRouteTemplate>;

                                                                                                                                                                                                                                                                                                                                                                    type DynamicRouteTemplate

                                                                                                                                                                                                                                                                                                                                                                    type DynamicRouteTemplate = __routes extends {
                                                                                                                                                                                                                                                                                                                                                                        DynamicRouteTemplate: string;
                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                        ? __routes['DynamicRouteTemplate']
                                                                                                                                                                                                                                                                                                                                                                        : string;

                                                                                                                                                                                                                                                                                                                                                                      type ExternalPathString

                                                                                                                                                                                                                                                                                                                                                                      type ExternalPathString = `${string}:${string}`;

                                                                                                                                                                                                                                                                                                                                                                        type Href

                                                                                                                                                                                                                                                                                                                                                                        type Href<T extends string | object = { __branded__: any }> =
                                                                                                                                                                                                                                                                                                                                                                            | StringRouteToType<
                                                                                                                                                                                                                                                                                                                                                                                  AllUngroupedRoutes<StaticRoutes> | RelativePathString | ExternalPathString
                                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                                            | DynamicRouteString<T, DynamicRouteTemplate>
                                                                                                                                                                                                                                                                                                                                                                            | DynamicRouteObject<
                                                                                                                                                                                                                                                                                                                                                                                  | StaticRoutes
                                                                                                                                                                                                                                                                                                                                                                                  | RelativePathString
                                                                                                                                                                                                                                                                                                                                                                                  | ExternalPathString
                                                                                                                                                                                                                                                                                                                                                                                  | DynamicRouteTemplate
                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                        • The main routing type for One. Includes all available routes with strongly typed parameters.

                                                                                                                                                                                                                                                                                                                                                                        type InpurRouteParamsGeneric

                                                                                                                                                                                                                                                                                                                                                                        type InpurRouteParamsGeneric = InputRouteParamsBlank | InputRouteParams<any>;

                                                                                                                                                                                                                                                                                                                                                                          type InputRouteParams

                                                                                                                                                                                                                                                                                                                                                                          type InputRouteParams<Path> = {
                                                                                                                                                                                                                                                                                                                                                                              [Key in ParameterNames<Path> as Key extends `...${infer Name}`
                                                                                                                                                                                                                                                                                                                                                                                  ? Name
                                                                                                                                                                                                                                                                                                                                                                                  : Key]: Key extends `...${string}` ? string[] : string;
                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                          • Returns a Record of the routes parameters as strings and CatchAll parameters

                                                                                                                                                                                                                                                                                                                                                                            There are two versions, input and output, as you can input 'string | number' but the output will always be 'string'

                                                                                                                                                                                                                                                                                                                                                                            /[id]/[...rest] -> { id: string, rest: string[] } /no-params -> {}

                                                                                                                                                                                                                                                                                                                                                                          type InputRouteParamsBlank

                                                                                                                                                                                                                                                                                                                                                                          type InputRouteParamsBlank = Record<string, string | undefined | null>;

                                                                                                                                                                                                                                                                                                                                                                          • ********************* One Exports * *********************

                                                                                                                                                                                                                                                                                                                                                                          type LinkToOptions

                                                                                                                                                                                                                                                                                                                                                                          type LinkToOptions = {
                                                                                                                                                                                                                                                                                                                                                                              scroll?: boolean;
                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                               * Display a different URL in the browser than the actual route.
                                                                                                                                                                                                                                                                                                                                                                               * Useful for modals and overlays that should show a clean URL.
                                                                                                                                                                                                                                                                                                                                                                               *
                                                                                                                                                                                                                                                                                                                                                                               * @example
                                                                                                                                                                                                                                                                                                                                                                               * ```tsx
                                                                                                                                                                                                                                                                                                                                                                               * // Navigate to /photos/5/modal but show /photos/5 in browser
                                                                                                                                                                                                                                                                                                                                                                               * router.navigate('/photos/5/modal', {
                                                                                                                                                                                                                                                                                                                                                                               *   mask: { href: '/photos/5' }
                                                                                                                                                                                                                                                                                                                                                                               * })
                                                                                                                                                                                                                                                                                                                                                                               * ```
                                                                                                                                                                                                                                                                                                                                                                               */
                                                                                                                                                                                                                                                                                                                                                                              mask?: {
                                                                                                                                                                                                                                                                                                                                                                                  /** The URL to display in the browser address bar */
                                                                                                                                                                                                                                                                                                                                                                                  href: Href;
                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                   * If true, unmask on page reload (show the masked URL in browser).
                                                                                                                                                                                                                                                                                                                                                                                   * If false (default), keep masking (navigate to actual route on reload).
                                                                                                                                                                                                                                                                                                                                                                                   */
                                                                                                                                                                                                                                                                                                                                                                                  unmaskOnReload?: boolean;
                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                               * Specify a scroll group for this navigation.
                                                                                                                                                                                                                                                                                                                                                                               * Routes within the same scroll group will preserve scroll position
                                                                                                                                                                                                                                                                                                                                                                               * when navigating between them.
                                                                                                                                                                                                                                                                                                                                                                               *
                                                                                                                                                                                                                                                                                                                                                                               * @example
                                                                                                                                                                                                                                                                                                                                                                               * ```tsx
                                                                                                                                                                                                                                                                                                                                                                               * // Use scroll group to preserve scroll when switching tabs
                                                                                                                                                                                                                                                                                                                                                                               * router.navigate('/dashboard/settings', {
                                                                                                                                                                                                                                                                                                                                                                               *   scrollGroup: '/dashboard'
                                                                                                                                                                                                                                                                                                                                                                               * })
                                                                                                                                                                                                                                                                                                                                                                               * ```
                                                                                                                                                                                                                                                                                                                                                                               */
                                                                                                                                                                                                                                                                                                                                                                              scrollGroup?: string;
                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                            type LoadingState

                                                                                                                                                                                                                                                                                                                                                                            type LoadingState = 'loading' | 'loaded';

                                                                                                                                                                                                                                                                                                                                                                              type LoadingStateListener

                                                                                                                                                                                                                                                                                                                                                                              type LoadingStateListener = (state: LoadingState) => void;

                                                                                                                                                                                                                                                                                                                                                                                type NavigationRef

                                                                                                                                                                                                                                                                                                                                                                                type NavigationRef = NavigationContainerRefWithCurrent<ParamListBase>;

                                                                                                                                                                                                                                                                                                                                                                                  type OneRouterRoutes

                                                                                                                                                                                                                                                                                                                                                                                  type OneRouterRoutes = DynamicRouteTemplate | StaticRoutes | RelativePathString;

                                                                                                                                                                                                                                                                                                                                                                                    type Redirect

                                                                                                                                                                                                                                                                                                                                                                                    type Redirect = typeof Redirect;

                                                                                                                                                                                                                                                                                                                                                                                      type RelativePathString

                                                                                                                                                                                                                                                                                                                                                                                      type RelativePathString = `./${string}` | `../${string}` | '..';

                                                                                                                                                                                                                                                                                                                                                                                        type ResultState

                                                                                                                                                                                                                                                                                                                                                                                        type ResultState = PartialState<NavigationState> & {
                                                                                                                                                                                                                                                                                                                                                                                            state?: ResultState;
                                                                                                                                                                                                                                                                                                                                                                                            hash?: string;
                                                                                                                                                                                                                                                                                                                                                                                            linkOptions?: OneRouter.LinkToOptions;
                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                          type RootStateListener

                                                                                                                                                                                                                                                                                                                                                                                          type RootStateListener = (state: ResultState) => void;

                                                                                                                                                                                                                                                                                                                                                                                            type Route

                                                                                                                                                                                                                                                                                                                                                                                            type Route<Path> = {
                                                                                                                                                                                                                                                                                                                                                                                                Params: InputRouteParams<Path>;
                                                                                                                                                                                                                                                                                                                                                                                                Props: { params: InputRouteParams<Path> };
                                                                                                                                                                                                                                                                                                                                                                                                Loader: (props: { params: InputRouteParams<Path> }) => any;
                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                              type Router

                                                                                                                                                                                                                                                                                                                                                                                              type Router = {
                                                                                                                                                                                                                                                                                                                                                                                                  /** Go back in the history. */
                                                                                                                                                                                                                                                                                                                                                                                                  back: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                  /** If there's history that supports invoking the `back` function. */
                                                                                                                                                                                                                                                                                                                                                                                                  canGoBack: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                  /** Navigate to the provided href using a push operation if possible. */
                                                                                                                                                                                                                                                                                                                                                                                                  push: (href: Href, options?: LinkToOptions) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  /** Navigate to the provided href. */
                                                                                                                                                                                                                                                                                                                                                                                                  navigate: (href: Href, options?: LinkToOptions) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  /** Navigate to route without appending to the history. */
                                                                                                                                                                                                                                                                                                                                                                                                  replace: (href: Href, options?: LinkToOptions) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  /** Navigate to the provided href using a push operation if possible. */
                                                                                                                                                                                                                                                                                                                                                                                                  dismiss: (count?: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  /** Navigate to first screen within the lowest stack. */
                                                                                                                                                                                                                                                                                                                                                                                                  dismissAll: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                  /** If there's history that supports invoking the `dismiss` and `dismissAll` function. */
                                                                                                                                                                                                                                                                                                                                                                                                  canDismiss: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                  /** Update the current route query params. */
                                                                                                                                                                                                                                                                                                                                                                                                  setParams: <T = ''>(
                                                                                                                                                                                                                                                                                                                                                                                                      params?: T extends '' ? InputRouteParamsBlank : InputRouteParams<T>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                  /** Subscribe to state updates from the router */
                                                                                                                                                                                                                                                                                                                                                                                                  subscribe: (listener: RootStateListener) => () => void;
                                                                                                                                                                                                                                                                                                                                                                                                  /** Subscribe to loading state updates */
                                                                                                                                                                                                                                                                                                                                                                                                  onLoadState: (listener: LoadingStateListener) => () => void;
                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                type RouteType

                                                                                                                                                                                                                                                                                                                                                                                                type RouteType<Path extends string> = Path extends keyof __routes['RouteTypes']
                                                                                                                                                                                                                                                                                                                                                                                                    ? __routes['RouteTypes'][Path]
                                                                                                                                                                                                                                                                                                                                                                                                    : {
                                                                                                                                                                                                                                                                                                                                                                                                          Params: InputRouteParams<Path>;
                                                                                                                                                                                                                                                                                                                                                                                                          LoaderProps: import('../types').LoaderProps<InputRouteParams<Path>>;
                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                • Helper type to get route information including params and loader props. Uses generated RouteTypes from routes.d.ts if available for better intellisense.

                                                                                                                                                                                                                                                                                                                                                                                                  Example 1

                                                                                                                                                                                                                                                                                                                                                                                                  const route = createRoute<'/docs/[slug]'>() // route.createLoader gets params typed as { slug: string }

                                                                                                                                                                                                                                                                                                                                                                                                  type Route = RouteType<'/docs/[slug]'> // Route.Params = { slug: string } // Route.LoaderProps = { path: string; params: { slug: string }; request?: Request }

                                                                                                                                                                                                                                                                                                                                                                                                type SearchParams

                                                                                                                                                                                                                                                                                                                                                                                                type SearchParams<T extends AllRoutes = never> = T extends DynamicRouteTemplate
                                                                                                                                                                                                                                                                                                                                                                                                    ? OutputRouteParams<T>
                                                                                                                                                                                                                                                                                                                                                                                                    : UnknownOutputParams;

                                                                                                                                                                                                                                                                                                                                                                                                • Returns the search parameters for a route. Static routes return UnknownOutputParams to allow extra query params.

                                                                                                                                                                                                                                                                                                                                                                                                type SingleRoutePart

                                                                                                                                                                                                                                                                                                                                                                                                type SingleRoutePart<S extends string> = S extends `${string}/${string}`
                                                                                                                                                                                                                                                                                                                                                                                                    ? never
                                                                                                                                                                                                                                                                                                                                                                                                    : S extends `${string}${SearchOrHash}`
                                                                                                                                                                                                                                                                                                                                                                                                    ? never
                                                                                                                                                                                                                                                                                                                                                                                                    : S extends ''
                                                                                                                                                                                                                                                                                                                                                                                                    ? never
                                                                                                                                                                                                                                                                                                                                                                                                    : S extends `(${string})`
                                                                                                                                                                                                                                                                                                                                                                                                    ? never
                                                                                                                                                                                                                                                                                                                                                                                                    : S extends `[${string}]`
                                                                                                                                                                                                                                                                                                                                                                                                    ? never
                                                                                                                                                                                                                                                                                                                                                                                                    : S;

                                                                                                                                                                                                                                                                                                                                                                                                • Return only the RoutePart of a string. If the string has multiple parts return never

                                                                                                                                                                                                                                                                                                                                                                                                  string | type ---------|------ 123 | 123 /123/abc | never 123?abc | never ./123 | never /123 | never 123/../ | never

                                                                                                                                                                                                                                                                                                                                                                                                type UnknownInputParams

                                                                                                                                                                                                                                                                                                                                                                                                type UnknownInputParams = Record<
                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                    string | number | undefined | null | (string | number)[]
                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                  namespace routerStore

                                                                                                                                                                                                                                                                                                                                                                                                  module 'src/router/router.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                  • Note: this entire module is exported as an interface router.* We need to treat exports as an API and not change them, maybe not the best decision.

                                                                                                                                                                                                                                                                                                                                                                                                  variable hasAttemptedToHideSplash

                                                                                                                                                                                                                                                                                                                                                                                                  let hasAttemptedToHideSplash: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                    variable initialPathname

                                                                                                                                                                                                                                                                                                                                                                                                    let initialPathname: string;

                                                                                                                                                                                                                                                                                                                                                                                                      variable initialState

                                                                                                                                                                                                                                                                                                                                                                                                      let initialState: any;

                                                                                                                                                                                                                                                                                                                                                                                                        variable lastIntendedPathname

                                                                                                                                                                                                                                                                                                                                                                                                        let lastIntendedPathname: string;

                                                                                                                                                                                                                                                                                                                                                                                                          variable navigationRef

                                                                                                                                                                                                                                                                                                                                                                                                          let navigationRef: NavigationContainerRefWithCurrent<ParamListBase>;

                                                                                                                                                                                                                                                                                                                                                                                                            variable preloadedLoaderData

                                                                                                                                                                                                                                                                                                                                                                                                            const preloadedLoaderData: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                              variable preloadingLoader

                                                                                                                                                                                                                                                                                                                                                                                                              const preloadingLoader: Record<string, Promise<any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                variable rootComponent

                                                                                                                                                                                                                                                                                                                                                                                                                let rootComponent: ComponentType;

                                                                                                                                                                                                                                                                                                                                                                                                                  variable rootState

                                                                                                                                                                                                                                                                                                                                                                                                                  let rootState: any;

                                                                                                                                                                                                                                                                                                                                                                                                                    variable routeInfo

                                                                                                                                                                                                                                                                                                                                                                                                                    let routeInfo: any;

                                                                                                                                                                                                                                                                                                                                                                                                                      variable routeNode

                                                                                                                                                                                                                                                                                                                                                                                                                      let routeNode: any;

                                                                                                                                                                                                                                                                                                                                                                                                                        function canDismiss

                                                                                                                                                                                                                                                                                                                                                                                                                        canDismiss: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                          function canGoBack

                                                                                                                                                                                                                                                                                                                                                                                                                          canGoBack: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                            function cleanup

                                                                                                                                                                                                                                                                                                                                                                                                                            cleanup: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              function consumePendingNavigationAction

                                                                                                                                                                                                                                                                                                                                                                                                                              consumePendingNavigationAction: () => 'NAVIGATE' | 'REPLACE' | 'PUSH';

                                                                                                                                                                                                                                                                                                                                                                                                                                function dismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                dismiss: (count?: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                  function dismissAll

                                                                                                                                                                                                                                                                                                                                                                                                                                  dismissAll: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                    function getPreloadHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                    getPreloadHistory: () => PreloadEntry[];

                                                                                                                                                                                                                                                                                                                                                                                                                                      function getSafeWindowPathname

                                                                                                                                                                                                                                                                                                                                                                                                                                      getSafeWindowPathname: () => string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                        function getSortedRoutes

                                                                                                                                                                                                                                                                                                                                                                                                                                        getSortedRoutes: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                          function getValidationState

                                                                                                                                                                                                                                                                                                                                                                                                                                          getValidationState: () => ValidationState;

                                                                                                                                                                                                                                                                                                                                                                                                                                            function goBack

                                                                                                                                                                                                                                                                                                                                                                                                                                            goBack: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                              function handleNavigationContainerStateChange

                                                                                                                                                                                                                                                                                                                                                                                                                                              handleNavigationContainerStateChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  navState: Readonly<NavigationState> | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                              • called by NavigationContainer's onStateChange callback uses onStateChange instead of addListener('state') because onStateChange always provides the full resolved state, avoiding partial state issues that can cause stale usePathname/useSegments values

                                                                                                                                                                                                                                                                                                                                                                                                                                              function initClientMatches

                                                                                                                                                                                                                                                                                                                                                                                                                                              initClientMatches: (matches: RouteMatch[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                              • Initialize client matches from server context during hydration. Called from createApp when hydrating.

                                                                                                                                                                                                                                                                                                                                                                                                                                              function initialize

                                                                                                                                                                                                                                                                                                                                                                                                                                              initialize: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  context: One.RouteContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ref: NavigationContainerRefWithCurrent<ParamListBase>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  initialLocation?: URL,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  linking?: OneLinkingConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                function isRouteProtected

                                                                                                                                                                                                                                                                                                                                                                                                                                                isRouteProtected: (href: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  function linkTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                  linkTo: (href: string, event?: string, options?: OneRouter.LinkToOptions) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    function navigate

                                                                                                                                                                                                                                                                                                                                                                                                                                                    navigate: (url: OneRouter.Href, options?: OneRouter.LinkToOptions) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      function preloadRoute

                                                                                                                                                                                                                                                                                                                                                                                                                                                      preloadRoute: (href: string, injectCSS?: boolean) => Promise<any> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        function push

                                                                                                                                                                                                                                                                                                                                                                                                                                                        push: (url: OneRouter.Href, options?: OneRouter.LinkToOptions) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function registerProtectedRoutes

                                                                                                                                                                                                                                                                                                                                                                                                                                                          registerProtectedRoutes: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              contextKey: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              guardedRedirects: Map<string, OneRouter.Href | undefined>
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Register protected routes for a navigator context. Called by navigators when their protectedScreens changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function replace

                                                                                                                                                                                                                                                                                                                                                                                                                                                          replace: (url: OneRouter.Href, options?: OneRouter.LinkToOptions) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function resolveProtectedHref

                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolveProtectedHref: (href: string) => string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            • resolve a protected href to its allowed redirect target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function rootStateSnapshot

                                                                                                                                                                                                                                                                                                                                                                                                                                                            rootStateSnapshot: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              function routeInfoSnapshot

                                                                                                                                                                                                                                                                                                                                                                                                                                                              routeInfoSnapshot: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                function setLoadingState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                setLoadingState: (state: OneRouter.LoadingState) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function setParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setParams: (params?: OneRouter.InpurRouteParamsGeneric) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function setValidationState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setValidationState: (state: ValidationState) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function snapshot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      snapshot: () => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          linkTo: (href: string, event?: string, options?: OneRouter.LinkToOptions) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          routeNode: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rootComponent: ComponentType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          linking: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hasAttemptedToHideSplash: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          initialState: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rootState: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nextState: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          routeInfo: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          splashScreenAnimationFrame: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          navigationRef: NavigationContainerRefWithCurrent<ParamListBase>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rootStateSubscribers: Set<OneRouter.RootStateListener>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          storeSubscribers: Set<() => void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function subscribeToLoadingState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        subscribeToLoadingState: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            subscriber: OneRouter.LoadingStateListener
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function subscribeToRootState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          subscribeToRootState: (subscriber: OneRouter.RootStateListener) => () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function subscribeToStore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            subscribeToStore: (subscriber: () => void) => () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function subscribeToValidationState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              subscribeToValidationState: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  subscriber: (state: ValidationState) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function unregisterProtectedRoutes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                unregisterProtectedRoutes: (contextKey: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Unregister protected routes for a navigator context. Called when a navigator unmounts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function updateState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                updateState: (state: OneRouter.ResultState, nextStateParam?: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function useOneRouter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  useOneRouter: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function useStoreRootState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    useStoreRootState: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function useStoreRouteInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      useStoreRouteInfo: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function useValidationState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        useValidationState: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PreloadEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PreloadEntry = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              href: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              status: PreloadStatus;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              startTime: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              endTime?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              error?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasLoader: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasCss: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PreloadStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PreloadStatus = 'pending' | 'loading' | 'loaded' | 'error';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ValidationState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ValidationState = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  status: 'idle' | 'validating' | 'error' | 'valid';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  error?: Error;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  lastValidatedHref?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace server-only

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                module 'server-only' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace web-only

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module 'web-only' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Package Files (56)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (55)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dev Dependencies (32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Peer Dependencies (16)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/one.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/one)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <a href="https://www.jsdocs.io/package/one"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>