@yahoo/uds-mobile 2.23.2 → 2.24.0-beta.1

package/dist/components/UDSProvider.d.cts

@@ -1,10 +1,18 @@
 
+import { FontScalingConfig } from "../fontScaling/types.cjs";
 import * as _$react from "react";
 import { ReactNode } from "react";
 
 //#region src/components/UDSProvider.d.ts
 interface UDSGestureProviderProps {
   children: ReactNode;
+  /**
+   * App-wide font-scaling caps, overriding the built-in defaults. Omit to use
+   * the defaults (display/title tiers capped, reading sizes uncapped, control
+   * internals capped at 2x). Should be identity-stable (a module constant or
+   * memoized) — every UDS text element reads it from context.
+   */
+  fontScaling?: FontScalingConfig;
 }
 /**
  * Root gesture and portal provider for UDS Mobile overlays.

package/dist/components/UDSProvider.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"UDSProvider.d.cts","names":[],"sources":["../../src/components/UDSProvider.tsx"],"mappings":";;;;;UAOU,uBAAA;EACR,QAAA,EAAU,SAAA;AAAA;AAR2B;;;;;AAQlB;;;;;AAqBG;;;;;AAwBxB;;;AArDuC,cA6BjC,kBAAA,EAAkB,OAAA,CAAA,oBAAA,CAAA,uBAAA;;;;cAWlB,WAAA,EAAW,OAAA,CAAA,oBAAA,CAAA,uBAAA;;;;KAaL,gBAAA,GAAmB,uBAAA"}
+{"version":3,"file":"UDSProvider.d.cts","names":[],"sources":["../../src/components/UDSProvider.tsx"],"mappings":";;;;;;UASU,uBAAA;EACR,QAAA,EAAU,SAAA;;AAJkD;;;;;EAW5D,WAAA,GAAc,iBAAA;AAAA;;;;AAAiB;;;;;AAqBT;;;;;AAiCxB;;;;;cAjCM,kBAAA,EAAkB,OAAA,CAAA,oBAAA,CAAA,uBAAA;;;;cAoBlB,WAAA,EAAW,OAAA,CAAA,oBAAA,CAAA,uBAAA;;;;KAaL,gBAAA,GAAmB,uBAAA"}

package/dist/components/UDSProvider.d.ts

@@ -1,10 +1,18 @@
 
+import { FontScalingConfig } from "../fontScaling/types.js";
 import * as _$react from "react";
 import { ReactNode } from "react";
 
 //#region src/components/UDSProvider.d.ts
 interface UDSGestureProviderProps {
   children: ReactNode;
+  /**
+   * App-wide font-scaling caps, overriding the built-in defaults. Omit to use
+   * the defaults (display/title tiers capped, reading sizes uncapped, control
+   * internals capped at 2x). Should be identity-stable (a module constant or
+   * memoized) — every UDS text element reads it from context.
+   */
+  fontScaling?: FontScalingConfig;
 }
 /**
  * Root gesture and portal provider for UDS Mobile overlays.

package/dist/components/UDSProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UDSProvider.d.ts","names":[],"sources":["../../src/components/UDSProvider.tsx"],"mappings":";;;;;UAOU,uBAAA;EACR,QAAA,EAAU,SAAA;AAAA;AAR2B;;;;;AAQlB;;;;;AAqBG;;;;;AAwBxB;;;AArDuC,cA6BjC,kBAAA,EAAkB,OAAA,CAAA,oBAAA,CAAA,uBAAA;;;;cAWlB,WAAA,EAAW,OAAA,CAAA,oBAAA,CAAA,uBAAA;;;;KAaL,gBAAA,GAAmB,uBAAA"}
+{"version":3,"file":"UDSProvider.d.ts","names":[],"sources":["../../src/components/UDSProvider.tsx"],"mappings":";;;;;;UASU,uBAAA;EACR,QAAA,EAAU,SAAA;;AAJkD;;;;;EAW5D,WAAA,GAAc,iBAAA;AAAA;;;;AAAiB;;;;;AAqBT;;;;;AAiCxB;;;;;cAjCM,kBAAA,EAAkB,OAAA,CAAA,oBAAA,CAAA,uBAAA;;;;cAoBlB,WAAA,EAAW,OAAA,CAAA,oBAAA,CAAA,uBAAA;;;;KAaL,gBAAA,GAAmB,uBAAA"}

package/dist/components/UDSProvider.js

@@ -1,5 +1,6 @@
 /*! © 2026 Yahoo, Inc. UDS Mobile v0.0.0-development */
 import { PortalProvider } from "../portal.js";
+import { UDSFontScalingProvider } from "../fontScaling/FontScalingContext.js";
 import { memo } from "react";
 import { StyleSheet } from "react-native";
 import { jsx } from "react/jsx-runtime";
@@ -23,10 +24,13 @@ import { GestureHandlerRootView } from "react-native-gesture-handler";
 * }
 * ```
 */
-const UDSGestureProvider = memo(function UDSGestureProvider({ children }) {
+const UDSGestureProvider = memo(function UDSGestureProvider({ children, fontScaling }) {
 	return /* @__PURE__ */ jsx(GestureHandlerRootView, {
 		style: styles.root,
-		children: /* @__PURE__ */ jsx(PortalProvider, { children })
+		children: /* @__PURE__ */ jsx(PortalProvider, { children: fontScaling ? /* @__PURE__ */ jsx(UDSFontScalingProvider, {
+			config: fontScaling,
+			children
+		}) : children })
 	});
 });
 /**

package/dist/components/UDSProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"UDSProvider.js","names":[],"sources":["../../src/components/UDSProvider.tsx"],"sourcesContent":["import type { ReactNode } from 'react';\nimport { memo } from 'react';\nimport { StyleSheet } from 'react-native';\nimport { GestureHandlerRootView } from 'react-native-gesture-handler';\n\nimport { PortalProvider } from '../portal';\n\ninterface UDSGestureProviderProps {\n  children: ReactNode;\n}\n\n/**\n * Root gesture and portal provider for UDS Mobile overlays.\n *\n * Place this at the top of your app layout:\n *\n * @example\n * ```tsx\n * import { UDSGestureProvider } from '@yahoo/uds-mobile/UDSGestureProvider';\n *\n * export default function RootLayout() {\n *   return (\n *     <UDSGestureProvider>\n *       <Stack />\n *     </UDSGestureProvider>\n *   );\n * }\n * ```\n */\nconst UDSGestureProvider = memo(function UDSGestureProvider({ children }: UDSGestureProviderProps) {\n  return (\n    <GestureHandlerRootView style={styles.root}>\n      <PortalProvider>{children}</PortalProvider>\n    </GestureHandlerRootView>\n  );\n});\n\n/**\n * @deprecated Use {@link UDSGestureProvider} from `@yahoo/uds-mobile/UDSGestureProvider`.\n */\nconst UDSProvider = UDSGestureProvider;\n\nconst styles = StyleSheet.create({\n  root: {\n    flex: 1,\n  },\n});\n\nexport { UDSGestureProvider, UDSProvider };\nexport type { UDSGestureProviderProps };\n/**\n * @deprecated Use {@link UDSGestureProviderProps}.\n */\nexport type UDSProviderProps = UDSGestureProviderProps;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAM,qBAAqB,KAAK,SAAS,mBAAmB,EAAE,YAAqC;CACjG,OACE,oBAAC,wBAAD;EAAwB,OAAO,OAAO;YACpC,oBAAC,gBAAD,EAAiB,UAA0B,CAAA;EACpB,CAAA;EAE3B;;;;AAKF,MAAM,cAAc;AAEpB,MAAM,SAAS,WAAW,OAAO,EAC/B,MAAM,EACJ,MAAM,GACP,EACF,CAAC"}
+{"version":3,"file":"UDSProvider.js","names":[],"sources":["../../src/components/UDSProvider.tsx"],"sourcesContent":["import type { ReactNode } from 'react';\nimport { memo } from 'react';\nimport { StyleSheet } from 'react-native';\nimport { GestureHandlerRootView } from 'react-native-gesture-handler';\n\nimport { UDSFontScalingProvider } from '../fontScaling/FontScalingContext';\nimport type { FontScalingConfig } from '../fontScaling/types';\nimport { PortalProvider } from '../portal';\n\ninterface UDSGestureProviderProps {\n  children: ReactNode;\n  /**\n   * App-wide font-scaling caps, overriding the built-in defaults. Omit to use\n   * the defaults (display/title tiers capped, reading sizes uncapped, control\n   * internals capped at 2x). Should be identity-stable (a module constant or\n   * memoized) — every UDS text element reads it from context.\n   */\n  fontScaling?: FontScalingConfig;\n}\n\n/**\n * Root gesture and portal provider for UDS Mobile overlays.\n *\n * Place this at the top of your app layout:\n *\n * @example\n * ```tsx\n * import { UDSGestureProvider } from '@yahoo/uds-mobile/UDSGestureProvider';\n *\n * export default function RootLayout() {\n *   return (\n *     <UDSGestureProvider>\n *       <Stack />\n *     </UDSGestureProvider>\n *   );\n * }\n * ```\n */\nconst UDSGestureProvider = memo(function UDSGestureProvider({\n  children,\n  fontScaling,\n}: UDSGestureProviderProps) {\n  return (\n    <GestureHandlerRootView style={styles.root}>\n      <PortalProvider>\n        {fontScaling ? (\n          <UDSFontScalingProvider config={fontScaling}>{children}</UDSFontScalingProvider>\n        ) : (\n          children\n        )}\n      </PortalProvider>\n    </GestureHandlerRootView>\n  );\n});\n\n/**\n * @deprecated Use {@link UDSGestureProvider} from `@yahoo/uds-mobile/UDSGestureProvider`.\n */\nconst UDSProvider = UDSGestureProvider;\n\nconst styles = StyleSheet.create({\n  root: {\n    flex: 1,\n  },\n});\n\nexport { UDSGestureProvider, UDSProvider };\nexport type { UDSGestureProviderProps };\n/**\n * @deprecated Use {@link UDSGestureProviderProps}.\n */\nexport type UDSProviderProps = UDSGestureProviderProps;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAM,qBAAqB,KAAK,SAAS,mBAAmB,EAC1D,UACA,eAC0B;CAC1B,OACE,oBAAC,wBAAD;EAAwB,OAAO,OAAO;YACpC,oBAAC,gBAAD,EAAA,UACG,cACC,oBAAC,wBAAD;GAAwB,QAAQ;GAAc;GAAkC,CAAA,GAEhF,UAEa,CAAA;EACM,CAAA;EAE3B;;;;AAKF,MAAM,cAAc;AAEpB,MAAM,SAAS,WAAW,OAAO,EAC/B,MAAM,EACJ,MAAM,GACP,EACF,CAAC"}

package/dist/fontScaling/FontScalingContext.cjs

@@ -0,0 +1,35 @@
+/*! © 2026 Yahoo, Inc. UDS Mobile v0.0.0-development */
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../_virtual/_rolldown/runtime.cjs");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/fontScaling/FontScalingContext.tsx
+const FontScalingContext = (0, react.createContext)(void 0);
+/**
+* **🔠 Overrides UDS font-scaling caps for a subtree**
+*
+* @description
+* Configures how UDS text and controls respond to the OS text-size setting.
+* Without a provider, built-in defaults apply (display/title tiers capped,
+* reading sizes uncapped, control internals capped at 2x). Most apps set this
+* once at the root via the `fontScaling` prop on `UDSGestureProvider`.
+*
+* @example
+* ```tsx
+* const FONT_SCALING = { default: 2, variants: { display1: 1.75 } };
+*
+* <UDSFontScalingProvider config={FONT_SCALING}>
+*   <App />
+* </UDSFontScalingProvider>
+* ```
+*/
+const UDSFontScalingProvider = (0, react.memo)(function UDSFontScalingProvider({ config, children }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FontScalingContext.Provider, {
+		value: config,
+		children
+	});
+});
+UDSFontScalingProvider.displayName = "UDSFontScalingProvider";
+//#endregion
+exports.FontScalingContext = FontScalingContext;
+exports.UDSFontScalingProvider = UDSFontScalingProvider;

package/dist/fontScaling/FontScalingContext.d.cts

@@ -0,0 +1,38 @@
+
+import { FontScalingConfig } from "./types.cjs";
+import * as _$react from "react";
+import { ReactNode } from "react";
+
+//#region src/fontScaling/FontScalingContext.d.ts
+declare const FontScalingContext: _$react.Context<FontScalingConfig | undefined>;
+interface UDSFontScalingProviderProps {
+  /**
+   * Font-scaling caps for the subtree. Should be identity-stable (a module
+   * constant or memoized) — every UDS text element reads it from context.
+   * The nearest provider wins wholesale; configs are not merged.
+   */
+  config: FontScalingConfig;
+  children: ReactNode;
+}
+/**
+ * **🔠 Overrides UDS font-scaling caps for a subtree**
+ *
+ * @description
+ * Configures how UDS text and controls respond to the OS text-size setting.
+ * Without a provider, built-in defaults apply (display/title tiers capped,
+ * reading sizes uncapped, control internals capped at 2x). Most apps set this
+ * once at the root via the `fontScaling` prop on `UDSGestureProvider`.
+ *
+ * @example
+ * ```tsx
+ * const FONT_SCALING = { default: 2, variants: { display1: 1.75 } };
+ *
+ * <UDSFontScalingProvider config={FONT_SCALING}>
+ *   <App />
+ * </UDSFontScalingProvider>
+ * ```
+ */
+declare const UDSFontScalingProvider: _$react.NamedExoticComponent<UDSFontScalingProviderProps>;
+//#endregion
+export { FontScalingContext, UDSFontScalingProvider, type UDSFontScalingProviderProps };
+//# sourceMappingURL=FontScalingContext.d.cts.map

package/dist/fontScaling/FontScalingContext.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontScalingContext.d.cts","names":[],"sources":["../../src/fontScaling/FontScalingContext.tsx"],"mappings":";;;;;;cAMM,kBAAA,EAAkB,OAAA,CAAA,OAAA,CAAA,iBAAA;AAAA,UAEd,2BAAA;;AALuC;;;;EAW/C,MAAA,EAAQ,iBAAA;EACR,QAAA,EAAU,SAAA;AAAA;;;;;;;;;AAAS;;;;;;;;;;cAqBf,sBAAA,EAAsB,OAAA,CAAA,oBAAA,CAAA,2BAAA"}

package/dist/fontScaling/FontScalingContext.d.ts

@@ -0,0 +1,38 @@
+
+import { FontScalingConfig } from "./types.js";
+import * as _$react from "react";
+import { ReactNode } from "react";
+
+//#region src/fontScaling/FontScalingContext.d.ts
+declare const FontScalingContext: _$react.Context<FontScalingConfig | undefined>;
+interface UDSFontScalingProviderProps {
+  /**
+   * Font-scaling caps for the subtree. Should be identity-stable (a module
+   * constant or memoized) — every UDS text element reads it from context.
+   * The nearest provider wins wholesale; configs are not merged.
+   */
+  config: FontScalingConfig;
+  children: ReactNode;
+}
+/**
+ * **🔠 Overrides UDS font-scaling caps for a subtree**
+ *
+ * @description
+ * Configures how UDS text and controls respond to the OS text-size setting.
+ * Without a provider, built-in defaults apply (display/title tiers capped,
+ * reading sizes uncapped, control internals capped at 2x). Most apps set this
+ * once at the root via the `fontScaling` prop on `UDSGestureProvider`.
+ *
+ * @example
+ * ```tsx
+ * const FONT_SCALING = { default: 2, variants: { display1: 1.75 } };
+ *
+ * <UDSFontScalingProvider config={FONT_SCALING}>
+ *   <App />
+ * </UDSFontScalingProvider>
+ * ```
+ */
+declare const UDSFontScalingProvider: _$react.NamedExoticComponent<UDSFontScalingProviderProps>;
+//#endregion
+export { FontScalingContext, UDSFontScalingProvider, type UDSFontScalingProviderProps };
+//# sourceMappingURL=FontScalingContext.d.ts.map

package/dist/fontScaling/FontScalingContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontScalingContext.d.ts","names":[],"sources":["../../src/fontScaling/FontScalingContext.tsx"],"mappings":";;;;;;cAMM,kBAAA,EAAkB,OAAA,CAAA,OAAA,CAAA,iBAAA;AAAA,UAEd,2BAAA;;AALuC;;;;EAW/C,MAAA,EAAQ,iBAAA;EACR,QAAA,EAAU,SAAA;AAAA;;;;;;;;;AAAS;;;;;;;;;;cAqBf,sBAAA,EAAsB,OAAA,CAAA,oBAAA,CAAA,2BAAA"}

package/dist/fontScaling/FontScalingContext.js

@@ -0,0 +1,34 @@
+/*! © 2026 Yahoo, Inc. UDS Mobile v0.0.0-development */
+import { createContext, memo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/fontScaling/FontScalingContext.tsx
+const FontScalingContext = createContext(void 0);
+/**
+* **🔠 Overrides UDS font-scaling caps for a subtree**
+*
+* @description
+* Configures how UDS text and controls respond to the OS text-size setting.
+* Without a provider, built-in defaults apply (display/title tiers capped,
+* reading sizes uncapped, control internals capped at 2x). Most apps set this
+* once at the root via the `fontScaling` prop on `UDSGestureProvider`.
+*
+* @example
+* ```tsx
+* const FONT_SCALING = { default: 2, variants: { display1: 1.75 } };
+*
+* <UDSFontScalingProvider config={FONT_SCALING}>
+*   <App />
+* </UDSFontScalingProvider>
+* ```
+*/
+const UDSFontScalingProvider = memo(function UDSFontScalingProvider({ config, children }) {
+	return /* @__PURE__ */ jsx(FontScalingContext.Provider, {
+		value: config,
+		children
+	});
+});
+UDSFontScalingProvider.displayName = "UDSFontScalingProvider";
+//#endregion
+export { FontScalingContext, UDSFontScalingProvider };
+
+//# sourceMappingURL=FontScalingContext.js.map

package/dist/fontScaling/FontScalingContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontScalingContext.js","names":[],"sources":["../../src/fontScaling/FontScalingContext.tsx"],"sourcesContent":["import type { ReactNode } from 'react';\nimport { createContext, memo } from 'react';\n\nimport type { FontScalingConfig } from './types';\n\n// undefined = no provider mounted; built-in defaults apply.\nconst FontScalingContext = createContext<FontScalingConfig | undefined>(undefined);\n\ninterface UDSFontScalingProviderProps {\n  /**\n   * Font-scaling caps for the subtree. Should be identity-stable (a module\n   * constant or memoized) — every UDS text element reads it from context.\n   * The nearest provider wins wholesale; configs are not merged.\n   */\n  config: FontScalingConfig;\n  children: ReactNode;\n}\n\n/**\n * **🔠 Overrides UDS font-scaling caps for a subtree**\n *\n * @description\n * Configures how UDS text and controls respond to the OS text-size setting.\n * Without a provider, built-in defaults apply (display/title tiers capped,\n * reading sizes uncapped, control internals capped at 2x). Most apps set this\n * once at the root via the `fontScaling` prop on `UDSGestureProvider`.\n *\n * @example\n * ```tsx\n * const FONT_SCALING = { default: 2, variants: { display1: 1.75 } };\n *\n * <UDSFontScalingProvider config={FONT_SCALING}>\n *   <App />\n * </UDSFontScalingProvider>\n * ```\n */\nconst UDSFontScalingProvider = memo(function UDSFontScalingProvider({\n  config,\n  children,\n}: UDSFontScalingProviderProps) {\n  return <FontScalingContext.Provider value={config}>{children}</FontScalingContext.Provider>;\n});\n\nUDSFontScalingProvider.displayName = 'UDSFontScalingProvider';\n\nexport { FontScalingContext, UDSFontScalingProvider, type UDSFontScalingProviderProps };\n"],"mappings":";;;;AAMA,MAAM,qBAAqB,cAA6C,KAAA,EAAU;;;;;;;;;;;;;;;;;;;AA8BlF,MAAM,yBAAyB,KAAK,SAAS,uBAAuB,EAClE,QACA,YAC8B;CAC9B,OAAO,oBAAC,mBAAmB,UAApB;EAA6B,OAAO;EAAS;EAAuC,CAAA;EAC3F;AAEF,uBAAuB,cAAc"}

package/dist/fontScaling/constants.cjs

@@ -0,0 +1,72 @@
+/*! © 2026 Yahoo, Inc. UDS Mobile v0.0.0-development */
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/fontScaling/constants.ts
+/**
+* The largest OS font scale UDS components are designed to support.
+*
+* Yahoo's inclusive-design guidance is to solve for text scaling up to 2x, so
+* no default cap exceeds it. Apple's Accessibility Nutrition Label for Larger
+* Text is claimable at "at least 200% or the maximum font size for the
+* system", so a 2x ceiling still qualifies. Note that iOS offers scales beyond
+* this (up to 3.571x): with this ceiling in place the top accessibility sizes
+* render alike, and an app that wants to follow the OS further can raise or
+* remove the caps via `UDSFontScalingProvider`.
+*/
+const MAX_SUPPORTED_FONT_SCALE = 2;
+/**
+* How far each text style would grow if only legibility mattered, following
+* the shape of Apple's Dynamic Type ramps: the larger a style starts, the less
+* it multiplies. At iOS's largest accessibility size the system grows body
+* (17pt) by 3.12x but largeTitle (34pt) by only ~1.71x, and UDS display tiers
+* are larger than largeTitle, so they taper hardest.
+*
+* Caps are chosen by the size a style starts at rather than by which family it
+* belongs to, which is why `ui1` (24pt) matches `title3` (24pt) and `ui2`
+* (20pt) matches `title4` (20pt). `null` means "no cap from the curve" — those
+* are reading sizes, where legibility argues for following the OS.
+*
+* The exported defaults are this curve clamped to {@link MAX_SUPPORTED_FONT_SCALE}.
+*/
+const TYPE_SCALE_CURVE = {
+	display1: 1.5,
+	display2: 1.6,
+	display3: 1.75,
+	title1: 1.8,
+	title2: 2,
+	title3: 2.2,
+	title4: 2.4,
+	headline1: 2.5,
+	ui1: 2.2,
+	ui2: 2.4,
+	body1: null,
+	label1: null,
+	label2: null,
+	label3: null,
+	label4: null,
+	caption1: null,
+	caption2: null,
+	legal1: null,
+	ui3: null,
+	ui4: null,
+	ui5: null,
+	ui6: null
+};
+/**
+* Default per-variant caps on OS font scaling, applied by `Text` when no
+* explicit prop or provider config overrides them: the legibility curve in
+* {@link TYPE_SCALE_CURVE}, clamped to the 2x we support.
+*
+* Keys are base variants; `/emphasized` twins resolve to their base.
+*/
+const DEFAULT_MAX_FONT_SIZE_MULTIPLIERS = Object.freeze(Object.fromEntries(Object.entries(TYPE_SCALE_CURVE).map(([variant, cap]) => [variant, cap === null ? 2 : Math.min(cap, 2)])));
+/**
+* Default cap for control-internal text and icons (Button, Checkbox, Radio,
+* Switch, Chip, Tabs, Icon). Controls have bounded layouts, so they get the
+* supported ceiling rather than a looser per-variant cap.
+*/
+const DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER = 2;
+//#endregion
+exports.DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER = DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER;
+exports.DEFAULT_MAX_FONT_SIZE_MULTIPLIERS = DEFAULT_MAX_FONT_SIZE_MULTIPLIERS;
+exports.MAX_SUPPORTED_FONT_SCALE = MAX_SUPPORTED_FONT_SCALE;
+exports.TYPE_SCALE_CURVE = TYPE_SCALE_CURVE;

package/dist/fontScaling/constants.d.cts

@@ -0,0 +1,49 @@
+
+import { TextVariant } from "../components/Text.cjs";
+import { FontScalingCapValue } from "./types.cjs";
+
+//#region src/fontScaling/constants.d.ts
+/**
+ * The largest OS font scale UDS components are designed to support.
+ *
+ * Yahoo's inclusive-design guidance is to solve for text scaling up to 2x, so
+ * no default cap exceeds it. Apple's Accessibility Nutrition Label for Larger
+ * Text is claimable at "at least 200% or the maximum font size for the
+ * system", so a 2x ceiling still qualifies. Note that iOS offers scales beyond
+ * this (up to 3.571x): with this ceiling in place the top accessibility sizes
+ * render alike, and an app that wants to follow the OS further can raise or
+ * remove the caps via `UDSFontScalingProvider`.
+ */
+declare const MAX_SUPPORTED_FONT_SCALE = 2;
+/**
+ * How far each text style would grow if only legibility mattered, following
+ * the shape of Apple's Dynamic Type ramps: the larger a style starts, the less
+ * it multiplies. At iOS's largest accessibility size the system grows body
+ * (17pt) by 3.12x but largeTitle (34pt) by only ~1.71x, and UDS display tiers
+ * are larger than largeTitle, so they taper hardest.
+ *
+ * Caps are chosen by the size a style starts at rather than by which family it
+ * belongs to, which is why `ui1` (24pt) matches `title3` (24pt) and `ui2`
+ * (20pt) matches `title4` (20pt). `null` means "no cap from the curve" — those
+ * are reading sizes, where legibility argues for following the OS.
+ *
+ * The exported defaults are this curve clamped to {@link MAX_SUPPORTED_FONT_SCALE}.
+ */
+declare const TYPE_SCALE_CURVE: Readonly<Partial<Record<TextVariant, FontScalingCapValue>>>;
+/**
+ * Default per-variant caps on OS font scaling, applied by `Text` when no
+ * explicit prop or provider config overrides them: the legibility curve in
+ * {@link TYPE_SCALE_CURVE}, clamped to the 2x we support.
+ *
+ * Keys are base variants; `/emphasized` twins resolve to their base.
+ */
+declare const DEFAULT_MAX_FONT_SIZE_MULTIPLIERS: Readonly<Partial<Record<TextVariant, FontScalingCapValue>>>;
+/**
+ * Default cap for control-internal text and icons (Button, Checkbox, Radio,
+ * Switch, Chip, Tabs, Icon). Controls have bounded layouts, so they get the
+ * supported ceiling rather than a looser per-variant cap.
+ */
+declare const DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER = 2;
+//#endregion
+export { DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER, DEFAULT_MAX_FONT_SIZE_MULTIPLIERS, MAX_SUPPORTED_FONT_SCALE, TYPE_SCALE_CURVE };
+//# sourceMappingURL=constants.d.cts.map

package/dist/fontScaling/constants.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.cts","names":[],"sources":["../../src/fontScaling/constants.ts"],"mappings":";;;;;;;AACmD;;;;;AAarB;;;;cAAxB,wBAAA;;;;;;;;;;;;;AAgB0E;;cAA1E,gBAAA,EAAkB,QAAA,CAAS,OAAA,CAAQ,MAAA,CAAO,WAAA,EAAa,mBAAA;;;;;;;;cAgCvD,iCAAA,EAAmC,QAAA,CACvC,OAAA,CAAQ,MAAA,CAAO,WAAA,EAAa,mBAAA;;;;;;cAexB,wCAAA"}

package/dist/fontScaling/constants.d.ts

@@ -0,0 +1,49 @@
+
+import { TextVariant } from "../components/Text.js";
+import { FontScalingCapValue } from "./types.js";
+
+//#region src/fontScaling/constants.d.ts
+/**
+ * The largest OS font scale UDS components are designed to support.
+ *
+ * Yahoo's inclusive-design guidance is to solve for text scaling up to 2x, so
+ * no default cap exceeds it. Apple's Accessibility Nutrition Label for Larger
+ * Text is claimable at "at least 200% or the maximum font size for the
+ * system", so a 2x ceiling still qualifies. Note that iOS offers scales beyond
+ * this (up to 3.571x): with this ceiling in place the top accessibility sizes
+ * render alike, and an app that wants to follow the OS further can raise or
+ * remove the caps via `UDSFontScalingProvider`.
+ */
+declare const MAX_SUPPORTED_FONT_SCALE = 2;
+/**
+ * How far each text style would grow if only legibility mattered, following
+ * the shape of Apple's Dynamic Type ramps: the larger a style starts, the less
+ * it multiplies. At iOS's largest accessibility size the system grows body
+ * (17pt) by 3.12x but largeTitle (34pt) by only ~1.71x, and UDS display tiers
+ * are larger than largeTitle, so they taper hardest.
+ *
+ * Caps are chosen by the size a style starts at rather than by which family it
+ * belongs to, which is why `ui1` (24pt) matches `title3` (24pt) and `ui2`
+ * (20pt) matches `title4` (20pt). `null` means "no cap from the curve" — those
+ * are reading sizes, where legibility argues for following the OS.
+ *
+ * The exported defaults are this curve clamped to {@link MAX_SUPPORTED_FONT_SCALE}.
+ */
+declare const TYPE_SCALE_CURVE: Readonly<Partial<Record<TextVariant, FontScalingCapValue>>>;
+/**
+ * Default per-variant caps on OS font scaling, applied by `Text` when no
+ * explicit prop or provider config overrides them: the legibility curve in
+ * {@link TYPE_SCALE_CURVE}, clamped to the 2x we support.
+ *
+ * Keys are base variants; `/emphasized` twins resolve to their base.
+ */
+declare const DEFAULT_MAX_FONT_SIZE_MULTIPLIERS: Readonly<Partial<Record<TextVariant, FontScalingCapValue>>>;
+/**
+ * Default cap for control-internal text and icons (Button, Checkbox, Radio,
+ * Switch, Chip, Tabs, Icon). Controls have bounded layouts, so they get the
+ * supported ceiling rather than a looser per-variant cap.
+ */
+declare const DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER = 2;
+//#endregion
+export { DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER, DEFAULT_MAX_FONT_SIZE_MULTIPLIERS, MAX_SUPPORTED_FONT_SCALE, TYPE_SCALE_CURVE };
+//# sourceMappingURL=constants.d.ts.map

package/dist/fontScaling/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../src/fontScaling/constants.ts"],"mappings":";;;;;;;AACmD;;;;;AAarB;;;;cAAxB,wBAAA;;;;;;;;;;;;;AAgB0E;;cAA1E,gBAAA,EAAkB,QAAA,CAAS,OAAA,CAAQ,MAAA,CAAO,WAAA,EAAa,mBAAA;;;;;;;;cAgCvD,iCAAA,EAAmC,QAAA,CACvC,OAAA,CAAQ,MAAA,CAAO,WAAA,EAAa,mBAAA;;;;;;cAexB,wCAAA"}

package/dist/fontScaling/constants.js

@@ -0,0 +1,70 @@
+/*! © 2026 Yahoo, Inc. UDS Mobile v0.0.0-development */
+//#region src/fontScaling/constants.ts
+/**
+* The largest OS font scale UDS components are designed to support.
+*
+* Yahoo's inclusive-design guidance is to solve for text scaling up to 2x, so
+* no default cap exceeds it. Apple's Accessibility Nutrition Label for Larger
+* Text is claimable at "at least 200% or the maximum font size for the
+* system", so a 2x ceiling still qualifies. Note that iOS offers scales beyond
+* this (up to 3.571x): with this ceiling in place the top accessibility sizes
+* render alike, and an app that wants to follow the OS further can raise or
+* remove the caps via `UDSFontScalingProvider`.
+*/
+const MAX_SUPPORTED_FONT_SCALE = 2;
+/**
+* How far each text style would grow if only legibility mattered, following
+* the shape of Apple's Dynamic Type ramps: the larger a style starts, the less
+* it multiplies. At iOS's largest accessibility size the system grows body
+* (17pt) by 3.12x but largeTitle (34pt) by only ~1.71x, and UDS display tiers
+* are larger than largeTitle, so they taper hardest.
+*
+* Caps are chosen by the size a style starts at rather than by which family it
+* belongs to, which is why `ui1` (24pt) matches `title3` (24pt) and `ui2`
+* (20pt) matches `title4` (20pt). `null` means "no cap from the curve" — those
+* are reading sizes, where legibility argues for following the OS.
+*
+* The exported defaults are this curve clamped to {@link MAX_SUPPORTED_FONT_SCALE}.
+*/
+const TYPE_SCALE_CURVE = {
+	display1: 1.5,
+	display2: 1.6,
+	display3: 1.75,
+	title1: 1.8,
+	title2: 2,
+	title3: 2.2,
+	title4: 2.4,
+	headline1: 2.5,
+	ui1: 2.2,
+	ui2: 2.4,
+	body1: null,
+	label1: null,
+	label2: null,
+	label3: null,
+	label4: null,
+	caption1: null,
+	caption2: null,
+	legal1: null,
+	ui3: null,
+	ui4: null,
+	ui5: null,
+	ui6: null
+};
+/**
+* Default per-variant caps on OS font scaling, applied by `Text` when no
+* explicit prop or provider config overrides them: the legibility curve in
+* {@link TYPE_SCALE_CURVE}, clamped to the 2x we support.
+*
+* Keys are base variants; `/emphasized` twins resolve to their base.
+*/
+const DEFAULT_MAX_FONT_SIZE_MULTIPLIERS = Object.freeze(Object.fromEntries(Object.entries(TYPE_SCALE_CURVE).map(([variant, cap]) => [variant, cap === null ? 2 : Math.min(cap, 2)])));
+/**
+* Default cap for control-internal text and icons (Button, Checkbox, Radio,
+* Switch, Chip, Tabs, Icon). Controls have bounded layouts, so they get the
+* supported ceiling rather than a looser per-variant cap.
+*/
+const DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER = 2;
+//#endregion
+export { DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER, DEFAULT_MAX_FONT_SIZE_MULTIPLIERS, MAX_SUPPORTED_FONT_SCALE, TYPE_SCALE_CURVE };
+
+//# sourceMappingURL=constants.js.map

package/dist/fontScaling/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../src/fontScaling/constants.ts"],"sourcesContent":["import type { TextVariant } from '../components/Text';\nimport type { FontScalingCapValue } from './types';\n\n/**\n * The largest OS font scale UDS components are designed to support.\n *\n * Yahoo's inclusive-design guidance is to solve for text scaling up to 2x, so\n * no default cap exceeds it. Apple's Accessibility Nutrition Label for Larger\n * Text is claimable at \"at least 200% or the maximum font size for the\n * system\", so a 2x ceiling still qualifies. Note that iOS offers scales beyond\n * this (up to 3.571x): with this ceiling in place the top accessibility sizes\n * render alike, and an app that wants to follow the OS further can raise or\n * remove the caps via `UDSFontScalingProvider`.\n */\nconst MAX_SUPPORTED_FONT_SCALE = 2;\n\n/**\n * How far each text style would grow if only legibility mattered, following\n * the shape of Apple's Dynamic Type ramps: the larger a style starts, the less\n * it multiplies. At iOS's largest accessibility size the system grows body\n * (17pt) by 3.12x but largeTitle (34pt) by only ~1.71x, and UDS display tiers\n * are larger than largeTitle, so they taper hardest.\n *\n * Caps are chosen by the size a style starts at rather than by which family it\n * belongs to, which is why `ui1` (24pt) matches `title3` (24pt) and `ui2`\n * (20pt) matches `title4` (20pt). `null` means \"no cap from the curve\" — those\n * are reading sizes, where legibility argues for following the OS.\n *\n * The exported defaults are this curve clamped to {@link MAX_SUPPORTED_FONT_SCALE}.\n */\nconst TYPE_SCALE_CURVE: Readonly<Partial<Record<TextVariant, FontScalingCapValue>>> = {\n  display1: 1.5,\n  display2: 1.6,\n  display3: 1.75,\n  title1: 1.8,\n  title2: 2,\n  title3: 2.2,\n  title4: 2.4,\n  headline1: 2.5,\n  ui1: 2.2,\n  ui2: 2.4,\n  body1: null,\n  label1: null,\n  label2: null,\n  label3: null,\n  label4: null,\n  caption1: null,\n  caption2: null,\n  legal1: null,\n  ui3: null,\n  ui4: null,\n  ui5: null,\n  ui6: null,\n};\n\n/**\n * Default per-variant caps on OS font scaling, applied by `Text` when no\n * explicit prop or provider config overrides them: the legibility curve in\n * {@link TYPE_SCALE_CURVE}, clamped to the 2x we support.\n *\n * Keys are base variants; `/emphasized` twins resolve to their base.\n */\nconst DEFAULT_MAX_FONT_SIZE_MULTIPLIERS: Readonly<\n  Partial<Record<TextVariant, FontScalingCapValue>>\n> = Object.freeze(\n  Object.fromEntries(\n    Object.entries(TYPE_SCALE_CURVE).map(([variant, cap]) => [\n      variant,\n      cap === null ? MAX_SUPPORTED_FONT_SCALE : Math.min(cap, MAX_SUPPORTED_FONT_SCALE),\n    ]),\n  ) as Partial<Record<TextVariant, FontScalingCapValue>>,\n);\n\n/**\n * Default cap for control-internal text and icons (Button, Checkbox, Radio,\n * Switch, Chip, Tabs, Icon). Controls have bounded layouts, so they get the\n * supported ceiling rather than a looser per-variant cap.\n */\nconst DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER = MAX_SUPPORTED_FONT_SCALE;\n\nexport {\n  DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER,\n  DEFAULT_MAX_FONT_SIZE_MULTIPLIERS,\n  MAX_SUPPORTED_FONT_SCALE,\n  TYPE_SCALE_CURVE,\n};\n"],"mappings":";;;;;;;;;;;;;AAcA,MAAM,2BAA2B;;;;;;;;;;;;;;;AAgBjC,MAAM,mBAAgF;CACpF,UAAU;CACV,UAAU;CACV,UAAU;CACV,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,WAAW;CACX,KAAK;CACL,KAAK;CACL,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,UAAU;CACV,QAAQ;CACR,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACN;;;;;;;;AASD,MAAM,oCAEF,OAAO,OACT,OAAO,YACL,OAAO,QAAQ,iBAAiB,CAAC,KAAK,CAAC,SAAS,SAAS,CACvD,SACA,QAAQ,OAAA,IAAkC,KAAK,IAAI,KAAA,EAA8B,CAClF,CAAC,CACH,CACF;;;;;;AAOD,MAAM,2CAAA"}

package/dist/fontScaling/index.cjs

@@ -0,0 +1,13 @@
+/*! © 2026 Yahoo, Inc. UDS Mobile v0.0.0-development */
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_fontScaling_FontScalingContext = require("./FontScalingContext.cjs");
+const require_fontScaling_constants = require("./constants.cjs");
+const require_fontScaling_useMaxFontSizeMultiplier = require("./useMaxFontSizeMultiplier.cjs");
+const require_fontScaling_useFontScale = require("./useFontScale.cjs");
+exports.DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER = require_fontScaling_constants.DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER;
+exports.DEFAULT_MAX_FONT_SIZE_MULTIPLIERS = require_fontScaling_constants.DEFAULT_MAX_FONT_SIZE_MULTIPLIERS;
+exports.MAX_SUPPORTED_FONT_SCALE = require_fontScaling_constants.MAX_SUPPORTED_FONT_SCALE;
+exports.TYPE_SCALE_CURVE = require_fontScaling_constants.TYPE_SCALE_CURVE;
+exports.UDSFontScalingProvider = require_fontScaling_FontScalingContext.UDSFontScalingProvider;
+exports.useFontScale = require_fontScaling_useFontScale.useFontScale;
+exports.useMaxFontSizeMultiplier = require_fontScaling_useMaxFontSizeMultiplier.useMaxFontSizeMultiplier;

package/dist/fontScaling/index.d.cts

@@ -0,0 +1,8 @@
+
+import { TextVariant } from "../components/Text.cjs";
+import { FontScalingCapValue, FontScalingConfig } from "./types.cjs";
+import { UDSFontScalingProvider, UDSFontScalingProviderProps } from "./FontScalingContext.cjs";
+import { DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER, DEFAULT_MAX_FONT_SIZE_MULTIPLIERS, MAX_SUPPORTED_FONT_SCALE, TYPE_SCALE_CURVE } from "./constants.cjs";
+import { useFontScale } from "./useFontScale.cjs";
+import { useMaxFontSizeMultiplier } from "./useMaxFontSizeMultiplier.cjs";
+export { DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER, DEFAULT_MAX_FONT_SIZE_MULTIPLIERS, type FontScalingCapValue, type FontScalingConfig, MAX_SUPPORTED_FONT_SCALE, TYPE_SCALE_CURVE, type TextVariant, UDSFontScalingProvider, type UDSFontScalingProviderProps, useFontScale, useMaxFontSizeMultiplier };

package/dist/fontScaling/index.d.ts

@@ -0,0 +1,8 @@
+
+import { TextVariant } from "../components/Text.js";
+import { FontScalingCapValue, FontScalingConfig } from "./types.js";
+import { UDSFontScalingProvider, UDSFontScalingProviderProps } from "./FontScalingContext.js";
+import { DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER, DEFAULT_MAX_FONT_SIZE_MULTIPLIERS, MAX_SUPPORTED_FONT_SCALE, TYPE_SCALE_CURVE } from "./constants.js";
+import { useFontScale } from "./useFontScale.js";
+import { useMaxFontSizeMultiplier } from "./useMaxFontSizeMultiplier.js";
+export { DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER, DEFAULT_MAX_FONT_SIZE_MULTIPLIERS, type FontScalingCapValue, type FontScalingConfig, MAX_SUPPORTED_FONT_SCALE, TYPE_SCALE_CURVE, type TextVariant, UDSFontScalingProvider, type UDSFontScalingProviderProps, useFontScale, useMaxFontSizeMultiplier };

package/dist/fontScaling/index.js

@@ -0,0 +1,6 @@
+/*! © 2026 Yahoo, Inc. UDS Mobile v0.0.0-development */
+import { UDSFontScalingProvider } from "./FontScalingContext.js";
+import { DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER, DEFAULT_MAX_FONT_SIZE_MULTIPLIERS, MAX_SUPPORTED_FONT_SCALE, TYPE_SCALE_CURVE } from "./constants.js";
+import { useMaxFontSizeMultiplier } from "./useMaxFontSizeMultiplier.js";
+import { useFontScale } from "./useFontScale.js";
+export { DEFAULT_CONTROL_MAX_FONT_SIZE_MULTIPLIER, DEFAULT_MAX_FONT_SIZE_MULTIPLIERS, MAX_SUPPORTED_FONT_SCALE, TYPE_SCALE_CURVE, UDSFontScalingProvider, useFontScale, useMaxFontSizeMultiplier };

package/dist/fontScaling/resolveMaxFontSizeMultiplier.cjs

@@ -0,0 +1,38 @@
+/*! © 2026 Yahoo, Inc. UDS Mobile v0.0.0-development */
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_fontScaling_constants = require("./constants.cjs");
+//#region src/fontScaling/resolveMaxFontSizeMultiplier.ts
+const UNCAPPED = 0;
+function toResolved(cap) {
+	return cap === null ? UNCAPPED : cap;
+}
+/**
+* Resolves the `maxFontSizeMultiplier` to hand to React Native.
+*
+* Precedence: explicit prop > provider config (variant entry, then base-variant
+* entry, then `default`) > built-in default table.
+*
+* Returns `undefined` (native behavior: inherit from parent text or app
+* global) when nothing applies — including for built-in uncapped variants, so
+* body text nested inside capped text still inherits the parent's cap. Only an
+* explicit `null` (prop or provider) maps to `0`, RN's force-uncap value.
+*/
+function resolveMaxFontSizeMultiplier({ explicit, config, variant }) {
+	if (explicit !== void 0) return toResolved(explicit);
+	if (config?.enabled === false) return;
+	if (variant === void 0) return config?.default !== void 0 ? toResolved(config.default) : void 0;
+	if (variant === "control") {
+		if (config?.control !== void 0) return toResolved(config.control);
+		return 2;
+	}
+	const baseVariant = variant.split("/")[0];
+	const variantCap = config?.variants?.[variant];
+	if (variantCap !== void 0) return toResolved(variantCap);
+	const baseVariantCap = config?.variants?.[baseVariant];
+	if (baseVariantCap !== void 0) return toResolved(baseVariantCap);
+	if (config?.default !== void 0) return toResolved(config.default);
+	const builtIn = require_fontScaling_constants.DEFAULT_MAX_FONT_SIZE_MULTIPLIERS[variant] ?? require_fontScaling_constants.DEFAULT_MAX_FONT_SIZE_MULTIPLIERS[baseVariant];
+	return typeof builtIn === "number" ? builtIn : void 0;
+}
+//#endregion
+exports.resolveMaxFontSizeMultiplier = resolveMaxFontSizeMultiplier;

package/dist/fontScaling/resolveMaxFontSizeMultiplier.d.cts

@@ -0,0 +1,36 @@
+
+import { TextVariant } from "../components/Text.cjs";
+import { FontScalingConfig } from "./types.cjs";
+
+//#region src/fontScaling/resolveMaxFontSizeMultiplier.d.ts
+interface ResolveMaxFontSizeMultiplierOptions {
+  /** Explicit component prop. `null` = force-uncap. Wins over everything. */
+  explicit?: number | null;
+  /** Provider config, if any provider is mounted. */
+  config?: FontScalingConfig;
+  /**
+   * The text's resolved variant, `'control'` for control-internal text/icons,
+   * or `undefined` for `variant="inherit"` text (no variant opinion — nested
+   * text inherits its parent's cap natively).
+   */
+  variant?: TextVariant | 'control';
+}
+/**
+ * Resolves the `maxFontSizeMultiplier` to hand to React Native.
+ *
+ * Precedence: explicit prop > provider config (variant entry, then base-variant
+ * entry, then `default`) > built-in default table.
+ *
+ * Returns `undefined` (native behavior: inherit from parent text or app
+ * global) when nothing applies — including for built-in uncapped variants, so
+ * body text nested inside capped text still inherits the parent's cap. Only an
+ * explicit `null` (prop or provider) maps to `0`, RN's force-uncap value.
+ */
+declare function resolveMaxFontSizeMultiplier({
+  explicit,
+  config,
+  variant
+}: ResolveMaxFontSizeMultiplierOptions): number | undefined;
+//#endregion
+export { type ResolveMaxFontSizeMultiplierOptions, resolveMaxFontSizeMultiplier };
+//# sourceMappingURL=resolveMaxFontSizeMultiplier.d.cts.map

package/dist/fontScaling/resolveMaxFontSizeMultiplier.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveMaxFontSizeMultiplier.d.cts","names":[],"sources":["../../src/fontScaling/resolveMaxFontSizeMultiplier.ts"],"mappings":";;;;;UAWU,mCAAA;;EAER,QAAA;EAF2C;EAI3C,MAAA,GAAS,iBAAA;EAMY;;;;;EAArB,OAAA,GAAU,WAAA;AAAA;;AAAW;;;;;;;;;;iBAkBd,4BAAA,CAAA;EACP,QAAA;EACA,MAAA;EACA;AAAA,GACC,mCAAA"}