@khanacademy/perseus 71.4.0 → 71.4.1

package/dist/math-rendering-context.d.ts

@@ -2,7 +2,7 @@
  * @fileoverview A React context for managing math rendering options.
  */
 import * as React from "react";
-export type MathRenderingContextType = {
+type MathRenderingContextType = {
     shouldAddAriaLabels: boolean;
 };
 /**
@@ -15,5 +15,5 @@ export type MathRenderingContextType = {
  * addition of aria labels for times when the element is not within such
  * containers.
  */
-export declare const MathRenderingContext: React.Context<MathRenderingContextType>;
+declare const MathRenderingContext: React.Context<MathRenderingContextType>;
 export default MathRenderingContext;

package/dist/mixins/widget-prop-denylist.d.ts

@@ -1,18 +1 @@
-/**
- * These are things that widgets should exclude when serializing themselves.
- *
- * The use of this list needs to die. Basically, there are codepaths that
- * blindly serialize the "props" of a widget so that it can pass around its
- * info. Unfortunately, props aren't guaranteed to be serializable, and
- * automatically serializing schemaless list of attributes causes issues (e.g.
- * circular JSON structures sometimes).
- *
- * This blocks things that we know don't need to be serialized.
- */
-/**
- * @deprecated and likely a very broken API
- * [LEMS-3185] do not trust serializedState
- */
-declare const denylist: string[];
 export declare function excludeDenylistKeys(obj: Record<any, any>): {};
-export default denylist;

package/dist/types.d.ts

@@ -101,7 +101,6 @@ export type GenerateUrlArgs = {
     url: string;
     context: GenerateUrlContext;
 };
-export type GenerateUrlFn = (args: GenerateUrlArgs) => string;
 /**
  * APIOptions provides different ways to customize the behaviour of Perseus.
  *
@@ -377,7 +376,7 @@ export type WidgetProps<TWidgetOptions, TUserInput = Empty, TrackingExtraArgs =
 /**
  * The props passed to every widget, regardless of its `type`.
  */
-export type UniversalWidgetProps<TUserInput = Empty, TrackingExtraArgs = Empty> = {
+type UniversalWidgetProps<TUserInput = Empty, TrackingExtraArgs = Empty> = {
     trackInteraction: (extraData?: TrackingExtraArgs) => void;
     widgetId: string;
     widgetIndex: number;

package/dist/util.d.ts

@@ -41,7 +41,7 @@ declare function inputPathsEqual(a?: ReadonlyArray<string> | null, b?: ReadonlyA
  */
 declare function firstNumericalParse(text: string): ParsedValue | null | undefined;
 declare function stringArrayOfSize(size: number): string[];
-export declare function stringArrayOfSize2D(opt: {
+declare function stringArrayOfSize2D(opt: {
     rows: number;
     columns: number;
 }): string[][];

package/dist/widgets/expression/expression.d.ts

@@ -145,7 +145,72 @@ declare function getCorrectUserInput(options: PerseusExpressionWidgetOptions): P
 declare const _default: {
     name: string;
     displayName: string;
-    widget: React.ForwardRefExoticComponent<Omit<Pick<PerseusExpressionWidgetOptions & import("../../types").UniversalWidgetProps<string, Empty> & Partial<import("../..").PerseusDependenciesV2> & {
+    widget: React.ForwardRefExoticComponent<Omit<Pick<PerseusExpressionWidgetOptions & {
+        trackInteraction: (extraData?: Empty | undefined) => void;
+        widgetId: string;
+        widgetIndex: number;
+        alignment: string | null | undefined;
+        static: boolean | null | undefined;
+        problemNum: number | null | undefined;
+        apiOptions: Readonly<Readonly<{
+            isArticle?: boolean;
+            onFocusChange?: (newFocusPath: import("../..").FocusPath, oldFocusPath: import("../..").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
+            GroupMetadataEditor?: React.ComponentType<any>;
+            showAlignmentOptions?: boolean;
+            readOnly?: boolean;
+            answerableCallback?: (arg1: boolean) => unknown;
+            getAnotherHint?: () => unknown;
+            interactionCallback?: (widgetData: {
+                [widgetId: string]: any;
+            }) => void;
+            groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            };
+            imagePreloader?: (dimensions: import("../../types").Dimensions) => React.ReactNode;
+            trackInteraction?: (args: {
+                type: string;
+                id: string;
+                correct?: boolean;
+            } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
+                visible: number;
+            }>) => void;
+            customKeypad?: boolean;
+            nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
+            isMobile?: boolean;
+            isMobileApp?: boolean;
+            setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+            hintProgressColor?: string;
+            canScrollPage?: boolean;
+            editorChangeDelay?: number;
+            flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
+        }> & {
+            baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
+            canScrollPage: NonNullable<import("../..").APIOptions["canScrollPage"]>;
+            editorChangeDelay: NonNullable<import("../..").APIOptions["editorChangeDelay"]>;
+            groupAnnotator: NonNullable<import("../..").APIOptions["groupAnnotator"]>;
+            isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
+            isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
+            isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
+            onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
+            readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
+            setDrawingAreaAvailable: NonNullable<import("../..").APIOptions["setDrawingAreaAvailable"]>;
+            showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
+        }>;
+        keypadElement?: any;
+        questionCompleted?: boolean;
+        onFocus: (blurPath: import("../..").FocusPath) => void;
+        onBlur: (blurPath: import("../..").FocusPath) => void;
+        findWidgets: (criterion: import("../../types").FilterCriterion) => ReadonlyArray<Widget>;
+        reviewMode: boolean;
+        showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
+        handleUserInput: (newUserInput: string, cb?: () => void, silent?: boolean) => void;
+        userInput: string;
+        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+        containerSizeClass: import("../../util/sizing-utils").SizeClass;
+    } & Partial<import("../..").PerseusDependenciesV2> & {
         apiOptions: NonNullable<ExternalProps["apiOptions"]>;
         buttonSets: NonNullable<ExternalProps["buttonSets"]>;
         functions: NonNullable<ExternalProps["functions"]>;

package/dist/widgets/interactive-graphs/backgrounds/utils.d.ts

@@ -9,11 +9,6 @@ export declare const getLabelTransform: (labelLocation: GraphConfig["labelLocati
     xLabelTransform: string;
     yLabelTransform: string;
 };
-/**
- * Calculate the maximum number of digits needed to display tick labels on the y-axis.
- * This accounts for both the integer part of the range values and decimal places in the tick step.
- */
-export declare const calculateMaxDigitsInRange: (range: [number, number], tickStep: number) => number;
 export declare const getLabelPosition: (graphInfo: GraphDimensions, labelLocation: GraphConfig["labelLocation"], tickStep: GraphConfig["tickStep"]) => vec.Vector2[];
 export declare const shouldShowLabel: (currentTick: number, range: [Interval, Interval], tickStep: number) => boolean;
 export declare function generateTickLocations(tickStep: number, min: number, max: number, otherAxisMin: number): number[];

package/dist/widgets/label-image/label-image.d.ts

@@ -111,7 +111,72 @@ declare const _default: {
     displayName: string;
     widget: React.ForwardRefExoticComponent<Omit<Omit<PerseusLabelImageWidgetOptions, "markers"> & {
         markers: ReadonlyArray<OptionalAnswersMarkerType>;
-    } & import("../../types").UniversalWidgetProps<PerseusLabelImageUserInput, Empty> & {
+    } & {
+        trackInteraction: (extraData?: Empty | undefined) => void;
+        widgetId: string;
+        widgetIndex: number;
+        alignment: string | null | undefined;
+        static: boolean | null | undefined;
+        problemNum: number | null | undefined;
+        apiOptions: Readonly<Readonly<{
+            isArticle?: boolean;
+            onFocusChange?: (newFocusPath: import("../..").FocusPath, oldFocusPath: import("../..").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
+            GroupMetadataEditor?: React.ComponentType<any>;
+            showAlignmentOptions?: boolean;
+            readOnly?: boolean;
+            answerableCallback?: (arg1: boolean) => unknown;
+            getAnotherHint?: () => unknown;
+            interactionCallback?: (widgetData: {
+                [widgetId: string]: any;
+            }) => void;
+            groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            };
+            imagePreloader?: (dimensions: import("../../types").Dimensions) => React.ReactNode;
+            trackInteraction?: (args: {
+                type: string;
+                id: string;
+                correct?: boolean;
+            } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
+                visible: number;
+            }>) => void;
+            customKeypad?: boolean;
+            nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
+            isMobile?: boolean;
+            isMobileApp?: boolean;
+            setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+            hintProgressColor?: string;
+            canScrollPage?: boolean;
+            editorChangeDelay?: number;
+            flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
+        }> & {
+            baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
+            canScrollPage: NonNullable<import("../..").APIOptions["canScrollPage"]>;
+            editorChangeDelay: NonNullable<import("../..").APIOptions["editorChangeDelay"]>;
+            groupAnnotator: NonNullable<import("../..").APIOptions["groupAnnotator"]>;
+            isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
+            isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
+            isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
+            onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
+            readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
+            setDrawingAreaAvailable: NonNullable<import("../..").APIOptions["setDrawingAreaAvailable"]>;
+            showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
+        }>;
+        keypadElement?: any;
+        questionCompleted?: boolean;
+        onFocus: (blurPath: import("../..").FocusPath) => void;
+        onBlur: (blurPath: import("../..").FocusPath) => void;
+        findWidgets: (criterion: import("../../types").FilterCriterion) => ReadonlyArray<Widget>;
+        reviewMode: boolean;
+        showSolutions?: ShowSolutions;
+        handleUserInput: (newUserInput: PerseusLabelImageUserInput, cb?: () => void, silent?: boolean) => void;
+        userInput: PerseusLabelImageUserInput;
+        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+        containerSizeClass: import("../../util/sizing-utils").SizeClass;
+    } & {
         analytics: DependencyProps["analytics"];
         preferredPopoverDirection?: PreferredPopoverDirection;
     }, keyof import("../..").PerseusDependenciesV2> & React.RefAttributes<LabelImage>>;

package/dist/widgets/numeric-input/numeric-input.d.ts

@@ -5,7 +5,72 @@ import type { Focusable } from "../../types";
  * component. It is responsible for rendering the UI elements of the Numeric
  * Input widget.
  */
-export declare const NumericInputComponent: React.ForwardRefExoticComponent<import("@khanacademy/perseus-core").PerseusNumericInputWidgetOptions & import("../../types").UniversalWidgetProps<import("@khanacademy/perseus-core").PerseusNumericInputUserInput, Empty> & {
+export declare const NumericInputComponent: React.ForwardRefExoticComponent<import("@khanacademy/perseus-core").PerseusNumericInputWidgetOptions & {
+    trackInteraction: (extraData?: Empty | undefined) => void;
+    widgetId: string;
+    widgetIndex: number;
+    alignment: string | null | undefined;
+    static: boolean | null | undefined;
+    problemNum: number | null | undefined;
+    apiOptions: Readonly<Readonly<{
+        isArticle?: boolean;
+        onFocusChange?: (newFocusPath: import("../..").FocusPath, oldFocusPath: import("../..").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
+        GroupMetadataEditor?: React.ComponentType<any>;
+        showAlignmentOptions?: boolean;
+        readOnly?: boolean;
+        answerableCallback?: (arg1: boolean) => unknown;
+        getAnotherHint?: () => unknown;
+        interactionCallback?: (widgetData: {
+            [widgetId: string]: any;
+        }) => void;
+        groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
+        imagePlaceholder?: React.ReactNode;
+        widgetPlaceholder?: React.ReactNode;
+        baseElements?: {
+            Link: React.ComponentType<any>;
+        };
+        imagePreloader?: (dimensions: import("../../types").Dimensions) => React.ReactNode;
+        trackInteraction?: (args: {
+            type: string;
+            id: string;
+            correct?: boolean;
+        } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
+            visible: number;
+        }>) => void;
+        customKeypad?: boolean;
+        nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
+        isMobile?: boolean;
+        isMobileApp?: boolean;
+        setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+        hintProgressColor?: string;
+        canScrollPage?: boolean;
+        editorChangeDelay?: number;
+        flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
+    }> & {
+        baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
+        canScrollPage: NonNullable<import("../..").APIOptions["canScrollPage"]>;
+        editorChangeDelay: NonNullable<import("../..").APIOptions["editorChangeDelay"]>;
+        groupAnnotator: NonNullable<import("../..").APIOptions["groupAnnotator"]>;
+        isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
+        isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
+        isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
+        onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
+        readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
+        setDrawingAreaAvailable: NonNullable<import("../..").APIOptions["setDrawingAreaAvailable"]>;
+        showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
+    }>;
+    keypadElement?: any;
+    questionCompleted?: boolean;
+    onFocus: (blurPath: import("../..").FocusPath) => void;
+    onBlur: (blurPath: import("../..").FocusPath) => void;
+    findWidgets: (criterion: import("../../types").FilterCriterion) => ReadonlyArray<import("../../types").Widget>;
+    reviewMode: boolean;
+    showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
+    handleUserInput: (newUserInput: import("@khanacademy/perseus-core").PerseusNumericInputUserInput, cb?: () => void, silent?: boolean) => void;
+    userInput: import("@khanacademy/perseus-core").PerseusNumericInputUserInput;
+    linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+    containerSizeClass: import("../../util/sizing-utils").SizeClass;
+} & {
     size: NonNullable<string>;
     rightAlign: NonNullable<boolean | undefined>;
     apiOptions: NonNullable<Readonly<Readonly<{

package/dist/widgets/numeric-input/utils.d.ts

@@ -1,12 +1,5 @@
 import type { PerseusStrings } from "../../strings";
 import type { PerseusNumericInputAnswerForm, PerseusNumericInputWidgetOptions } from "@khanacademy/perseus-core";
-/**
- * The full list of available strings for the numeric input widget,
- * based on whether the Content Creator has specified that the answer must be simplified.
- */
-export declare const NumericExampleStrings: {
-    [key: string]: (form: PerseusNumericInputAnswerForm, strings: PerseusStrings) => string;
-};
 /**
  * Generates the specific set of examples for the current question.
  * This string is shown as examples to the user in a tooltip.

package/dist/widgets/plotter/plotter.d.ts

@@ -23,7 +23,7 @@ type DefaultProps = {
 type State = {
     categoryHeights: Record<string, number>;
 };
-export declare class Plotter extends React.Component<Props, State> implements Widget {
+declare class Plotter extends React.Component<Props, State> implements Widget {
     static contextType: React.Context<import("../../components/i18n-context").I18nContextType>;
     context: React.ContextType<typeof PerseusI18nContext>;
     _isMounted: boolean;

package/dist/widgets/radio/multiple-choice-widget.new.d.ts

@@ -1,6 +1,7 @@
 import * as React from "react";
 import type { ChoiceState, Widget, ChangeHandler } from "../../types";
 import type { PerseusRadioChoice, PerseusRadioRubric, PerseusRadioUserInput } from "@khanacademy/perseus-core";
+import type { LinterContextProps } from "@khanacademy/perseus-linter";
 /**
  * Represents a single choice in the MultipleChoiceComponent
  */
@@ -18,7 +19,7 @@ export interface ChoiceType {
     revealNoneOfTheAbove: boolean;
     disabled: boolean;
 }
-export type RadioProps = {
+type RadioProps = {
     numCorrect: number;
     hasNoneOfTheAbove?: boolean;
     multipleSelect?: boolean;
@@ -37,5 +38,70 @@ export interface RadioChoiceWithMetadata extends PerseusRadioChoice {
     originalIndex: number;
     correct?: boolean;
 }
-declare const Radio: React.ForwardRefExoticComponent<RadioProps & import("../../types").UniversalWidgetProps<PerseusRadioUserInput, PerseusRadioRubric> & React.RefAttributes<Widget>>;
+declare const Radio: React.ForwardRefExoticComponent<RadioProps & {
+    trackInteraction: (extraData?: PerseusRadioRubric | undefined) => void;
+    widgetId: string;
+    widgetIndex: number;
+    alignment: string | null | undefined;
+    static: boolean | null | undefined;
+    problemNum: number | null | undefined;
+    apiOptions: Readonly<Readonly<{
+        isArticle?: boolean;
+        onFocusChange?: (newFocusPath: import("../..").FocusPath, oldFocusPath: import("../..").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
+        GroupMetadataEditor?: React.ComponentType<any>;
+        showAlignmentOptions?: boolean;
+        readOnly?: boolean;
+        answerableCallback?: (arg1: boolean) => unknown;
+        getAnotherHint?: () => unknown;
+        interactionCallback?: (widgetData: {
+            [widgetId: string]: any;
+        }) => void;
+        groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
+        imagePlaceholder?: React.ReactNode;
+        widgetPlaceholder?: React.ReactNode;
+        baseElements?: {
+            Link: React.ComponentType<any>;
+        };
+        imagePreloader?: (dimensions: import("../../types").Dimensions) => React.ReactNode;
+        trackInteraction?: (args: {
+            type: string;
+            id: string;
+            correct?: boolean;
+        } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
+            visible: number;
+        }>) => void;
+        customKeypad?: boolean;
+        nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
+        isMobile?: boolean;
+        isMobileApp?: boolean;
+        setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+        hintProgressColor?: string;
+        canScrollPage?: boolean;
+        editorChangeDelay?: number;
+        flags?: Record<"new-radio-widget" | "image-widget-upgrade", boolean>;
+    }> & {
+        baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
+        canScrollPage: NonNullable<import("../..").APIOptions["canScrollPage"]>;
+        editorChangeDelay: NonNullable<import("../..").APIOptions["editorChangeDelay"]>;
+        groupAnnotator: NonNullable<import("../..").APIOptions["groupAnnotator"]>;
+        isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
+        isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
+        isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
+        onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
+        readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
+        setDrawingAreaAvailable: NonNullable<import("../..").APIOptions["setDrawingAreaAvailable"]>;
+        showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
+    }>;
+    keypadElement?: any;
+    questionCompleted?: boolean;
+    onFocus: (blurPath: import("../..").FocusPath) => void;
+    onBlur: (blurPath: import("../..").FocusPath) => void;
+    findWidgets: (criterion: import("../../types").FilterCriterion) => ReadonlyArray<Widget>;
+    reviewMode: boolean;
+    showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
+    handleUserInput: (newUserInput: PerseusRadioUserInput, cb?: () => void, silent?: boolean) => void;
+    userInput: PerseusRadioUserInput;
+    linterContext: LinterContextProps;
+    containerSizeClass: import("../../util/sizing-utils").SizeClass;
+} & React.RefAttributes<Widget>>;
 export default Radio;

package/dist/widgets/radio/radio-component.d.ts

@@ -15,7 +15,7 @@ export type RadioProps = PerseusRadioWidgetOptions & {
     choiceStates?: ChoiceState[];
     onChange: ChangeHandler;
 };
-export type Props = WidgetProps<RadioProps, PerseusRadioUserInput, PerseusRadioRubric>;
+type Props = WidgetProps<RadioProps, PerseusRadioUserInput, PerseusRadioRubric>;
 type DefaultProps = Required<Pick<Props, "choices" | "multipleSelect" | "countChoices" | "deselectEnabled" | "linterContext" | "showSolutions">>;
 export type RadioChoiceWithMetadata = PerseusRadioChoice & {
     originalIndex: number;

package/package.json

@@ -3,7 +3,7 @@
   "description": "Core Perseus API (includes renderers and widgets)",
   "author": "Khan Academy",
   "license": "MIT",
-  "version": "71.4.0",
+  "version": "71.4.1",
   "publishConfig": {
     "access": "public"
   },
@@ -42,45 +42,44 @@
     "tiny-invariant": "1.3.1",
     "uuid": "^10.0.0",
     "@khanacademy/kas": "2.1.3",
-    "@khanacademy/keypad-context": "3.2.14",
-    "@khanacademy/kmath": "2.2.14",
-    "@khanacademy/math-input": "26.2.15",
-    "@khanacademy/perseus-core": "20.1.2",
-    "@khanacademy/perseus-linter": "4.4.4",
-    "@khanacademy/perseus-score": "8.0.3",
+    "@khanacademy/keypad-context": "3.2.15",
+    "@khanacademy/kmath": "2.2.15",
+    "@khanacademy/math-input": "26.2.16",
+    "@khanacademy/perseus-core": "20.1.3",
+    "@khanacademy/perseus-linter": "4.4.5",
+    "@khanacademy/perseus-score": "8.0.4",
     "@khanacademy/perseus-utils": "2.1.1",
     "@khanacademy/pure-markdown": "2.2.1",
     "@khanacademy/simple-markdown": "2.1.1"
   },
   "devDependencies": {
-    "@khanacademy/wonder-blocks-announcer": "1.0.3",
-    "@khanacademy/wonder-blocks-banner": "4.5.2",
-    "@khanacademy/wonder-blocks-button": "11.2.4",
-    "@khanacademy/wonder-blocks-clickable": "8.0.0",
-    "@khanacademy/wonder-blocks-core": "12.4.0",
-    "@khanacademy/wonder-blocks-data": "14.1.6",
-    "@khanacademy/wonder-blocks-dropdown": "10.4.5",
-    "@khanacademy/wonder-blocks-form": "7.4.1",
-    "@khanacademy/wonder-blocks-icon-button": "10.5.3",
-    "@khanacademy/wonder-blocks-icon": "5.3.0",
-    "@khanacademy/wonder-blocks-labeled-field": "4.0.6",
-    "@khanacademy/wonder-blocks-layout": "3.1.37",
-    "@khanacademy/wonder-blocks-link": "10.0.1",
-    "@khanacademy/wonder-blocks-modal": "8.4.6",
-    "@khanacademy/wonder-blocks-pill": "3.1.43",
-    "@khanacademy/wonder-blocks-popover": "6.1.36",
-    "@khanacademy/wonder-blocks-progress-spinner": "3.1.37",
-    "@khanacademy/wonder-blocks-switch": "3.3.20",
-    "@khanacademy/wonder-blocks-timing": "7.0.2",
-    "@khanacademy/wonder-blocks-tokens": "14.0.0",
-    "@khanacademy/wonder-blocks-tooltip": "4.1.50",
-    "@khanacademy/wonder-blocks-typography": "4.2.22",
+    "@khanacademy/wonder-blocks-announcer": "1.0.4",
+    "@khanacademy/wonder-blocks-banner": "5.0.2",
+    "@khanacademy/wonder-blocks-button": "11.2.6",
+    "@khanacademy/wonder-blocks-clickable": "8.0.2",
+    "@khanacademy/wonder-blocks-core": "12.4.1",
+    "@khanacademy/wonder-blocks-data": "14.1.7",
+    "@khanacademy/wonder-blocks-dropdown": "10.4.10",
+    "@khanacademy/wonder-blocks-form": "7.4.3",
+    "@khanacademy/wonder-blocks-icon-button": "10.5.5",
+    "@khanacademy/wonder-blocks-icon": "5.3.2",
+    "@khanacademy/wonder-blocks-labeled-field": "4.0.8",
+    "@khanacademy/wonder-blocks-layout": "3.1.39",
+    "@khanacademy/wonder-blocks-link": "10.0.3",
+    "@khanacademy/wonder-blocks-modal": "8.5.3",
+    "@khanacademy/wonder-blocks-pill": "3.1.45",
+    "@khanacademy/wonder-blocks-popover": "6.1.40",
+    "@khanacademy/wonder-blocks-progress-spinner": "3.1.39",
+    "@khanacademy/wonder-blocks-switch": "3.3.22",
+    "@khanacademy/wonder-blocks-timing": "7.0.3",
+    "@khanacademy/wonder-blocks-tokens": "14.1.0",
+    "@khanacademy/wonder-blocks-tooltip": "4.1.54",
+    "@khanacademy/wonder-blocks-typography": "4.2.24",
     "@khanacademy/wonder-stuff-core": "1.5.5",
     "@phosphor-icons/core": "2.0.2",
     "@popperjs/core": "2.10.2",
     "aphrodite": "1.2.5",
     "classnames": "1.1.4",
-    "csstype": "^3.1.3",
     "intersection-observer": "^0.12.0",
     "jquery": "2.1.1",
     "lodash.debounce": "^4.0.8",
@@ -93,28 +92,28 @@
     "raphael": "1.5.4"
   },
   "peerDependencies": {
-    "@khanacademy/wonder-blocks-announcer": "^1.0.3",
-    "@khanacademy/wonder-blocks-banner": "^4.5.2",
-    "@khanacademy/wonder-blocks-button": "^11.2.4",
-    "@khanacademy/wonder-blocks-clickable": "^8.0.0",
-    "@khanacademy/wonder-blocks-core": "^12.4.0",
-    "@khanacademy/wonder-blocks-data": "^14.1.6",
-    "@khanacademy/wonder-blocks-dropdown": "^10.4.5",
-    "@khanacademy/wonder-blocks-form": "^7.4.1",
-    "@khanacademy/wonder-blocks-icon": "^5.3.0",
-    "@khanacademy/wonder-blocks-icon-button": "^10.5.3",
-    "@khanacademy/wonder-blocks-labeled-field": "^4.0.6",
-    "@khanacademy/wonder-blocks-layout": "^3.1.37",
-    "@khanacademy/wonder-blocks-link": "^10.0.1",
-    "@khanacademy/wonder-blocks-modal": "^8.4.6",
-    "@khanacademy/wonder-blocks-pill": "^3.1.43",
-    "@khanacademy/wonder-blocks-popover": "^6.1.36",
-    "@khanacademy/wonder-blocks-progress-spinner": "^3.1.37",
-    "@khanacademy/wonder-blocks-switch": "^3.3.20",
-    "@khanacademy/wonder-blocks-timing": "^7.0.2",
-    "@khanacademy/wonder-blocks-tokens": "^14.0.0",
-    "@khanacademy/wonder-blocks-tooltip": "^4.1.50",
-    "@khanacademy/wonder-blocks-typography": "^4.2.22",
+    "@khanacademy/wonder-blocks-announcer": "^1.0.4",
+    "@khanacademy/wonder-blocks-banner": "^5.0.2",
+    "@khanacademy/wonder-blocks-button": "^11.2.6",
+    "@khanacademy/wonder-blocks-clickable": "^8.0.2",
+    "@khanacademy/wonder-blocks-core": "^12.4.1",
+    "@khanacademy/wonder-blocks-data": "^14.1.7",
+    "@khanacademy/wonder-blocks-dropdown": "^10.4.10",
+    "@khanacademy/wonder-blocks-form": "^7.4.3",
+    "@khanacademy/wonder-blocks-icon": "^5.3.2",
+    "@khanacademy/wonder-blocks-icon-button": "^10.5.5",
+    "@khanacademy/wonder-blocks-labeled-field": "^4.0.8",
+    "@khanacademy/wonder-blocks-layout": "^3.1.39",
+    "@khanacademy/wonder-blocks-link": "^10.0.3",
+    "@khanacademy/wonder-blocks-modal": "^8.5.3",
+    "@khanacademy/wonder-blocks-pill": "^3.1.45",
+    "@khanacademy/wonder-blocks-popover": "^6.1.40",
+    "@khanacademy/wonder-blocks-progress-spinner": "^3.1.39",
+    "@khanacademy/wonder-blocks-switch": "^3.3.22",
+    "@khanacademy/wonder-blocks-timing": "^7.0.3",
+    "@khanacademy/wonder-blocks-tokens": "^14.1.0",
+    "@khanacademy/wonder-blocks-tooltip": "^4.1.54",
+    "@khanacademy/wonder-blocks-typography": "^4.2.24",
     "@khanacademy/wonder-stuff-core": "^1.5.5",
     "@phosphor-icons/core": "^2.0.2",
     "@popperjs/core": "^2.10.2",

package/dist/components/visibility-observer/create-visibility-observer.d.ts

@@ -1,34 +0,0 @@
-/**
- * VisibilityObserver watches a target element for changes to visibility,
- * relative to a given root node.
- *
- * When the target element entirely disappears, or partially reappears, the
- * caller is notified via the `onVisibilityChange` callback.
- *
- * Potential visibility changes include:
- *   - Being scrolled out of view, by any scroll container between the target
- *         and the root.
- *   - Style changes to the target element or an ancestor, like `display: none`.
- *
- * The VisibilityObserver relies on the IntersectionObserver, which does not
- * exist on Safari and is buggy on Edge.  Instead, we will polyfill the
- * IntersectionObserver on those platforms.
- *
- * TODO(mdr): Currently, we emulate the API of IntersectionObserver. It might
- *     be nicer to instead use a more React-y API: let `targetElement` be a
- *     required prop, and render the element only when it's present. Then, we
- *     can use React lifecycle methods to set-up/tear-down handlers. Not sure
- *     that's _actually_ a net win, though, in complexity or performance - but
- *     worth thinking about if this API is causing too much entanglement!
- */
-import "intersection-observer";
-export interface VisibilityObserver {
-    setTargetElement(targetElement: HTMLElement): void;
-    disconnect(): void;
-}
-type VisibilityChangeCallback = (isVisible: boolean, rootBounds: DOMRectReadOnly) => void;
-/**
- * Create a new VisibilityObserver.
- */
-export declare function createVisibilityObserver(rootElement: HTMLElement | null | undefined, onVisibilityChange: VisibilityChangeCallback, rootMargin?: string): VisibilityObserver;
-export {};

package/dist/components/visibility-observer/get-scroll-parent.d.ts

@@ -1 +0,0 @@
-export declare const getScrollParent: (node: Element) => Element | null | undefined;

package/dist/components/visibility-observer/visibility-observer.d.ts

@@ -1,31 +0,0 @@
-/**
- * This is a wrapper component for the visibility-observer.js utility which
- * abstracts the native or polyfilled IntersectionObserver utility.  The
- * primary purpose of this comonent is to tell you whether the children of
- * the component are visibile within a scrollable ancestor.  It will notify
- * you via an onChange event when the visibility changes, and whether the
- * children are below or above the scroll.
- */
-import * as React from "react";
-import type { VisibilityObserver as IVisibilityObserver } from "./create-visibility-observer";
-export type ScrollVisibility = "hidden-above" | "hidden-below" | "visible" | "unknown";
-type Props = {
-    children: React.ReactNode;
-    rootMargin?: string;
-    scrollParentIsNotBody?: boolean;
-    onChange: (visibility: ScrollVisibility) => void;
-};
-declare class VisibilityObserver extends React.Component<Props> {
-    _observer: IVisibilityObserver;
-    _node: HTMLElement;
-    static defaultProps: {
-        onChange: () => void;
-    };
-    componentDidMount(): void;
-    componentWillUnmount(): void;
-    handleVisibilityChange: (isVisible: boolean, rootBounds: DOMRectReadOnly) => void;
-    registerVisibilityObserver(): void;
-    unregisterVisibilityObserver(): void;
-    render(): React.ReactNode;
-}
-export default VisibilityObserver;

package/dist/widgets/radio/choice-icon/choice-icon-styles.d.ts

@@ -1,9 +0,0 @@
-export declare const CHOICE_ICON_SIZE = 24;
-declare const styles: {
-    readonly iconWrapper: {
-        readonly display: "inline-block";
-        readonly position: "relative";
-        readonly background: "linear-gradient(to right, white 10%, transparent)";
-    };
-};
-export default styles;