@khanacademy/perseus 21.5.0 → 22.0.0

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 import type { ILogger } from "./logging/log";
 import type { Item } from "./multi-items/item-types";
 import type { PerseusAnswerArea, PerseusRenderer, PerseusWidget, PerseusWidgetsMap } from "./perseus-types";
+import type { PerseusStrings } from "./strings";
 import type { SizeClass } from "./util/sizing-utils";
 import type { InteractiveGraphState } from "./widgets/interactive-graphs/types";
 import type { KeypadAPI } from "@khanacademy/math-input";
@@ -77,7 +78,8 @@ type TrackInteractionArgs = {
     id: string;
     correct?: boolean;
 } & Partial<TrackingGradedGroupExtraArguments> & Partial<TrackingSequenceExtraArguments>;
-export declare const MafsFlags: readonly ["segment", "linear", "linear-system", "ray", "polygon"];
+export declare const MafsGraphTypeFlags: readonly ["segment", "linear", "linear-system", "ray", "polygon"];
+export declare const InteractiveGraphLockedFeaturesFlags: readonly ["interactive-graph-locked-features-m1"];
 /**
  * APIOptions provides different ways to customize the behaviour of Perseus.
  *
@@ -203,11 +205,13 @@ export type APIOptions = Readonly<{
         /**
          * Flags related to the interactive-graph Mafs migration.
          *
-         * Add values to the `MafsFlags` array to create new flags.
+         * Add values to the relevant array to create new flags.
          */
-        mafs?: false | {
-            [Key in (typeof MafsFlags)[number]]?: boolean;
-        };
+        mafs?: false | ({
+            [Key in (typeof MafsGraphTypeFlags)[number]]?: boolean;
+        } & {
+            [Key in (typeof InteractiveGraphLockedFeaturesFlags)[number]]?: boolean;
+        });
     };
     /**
      * This is a callback function that returns all of the Widget props
@@ -321,7 +325,7 @@ export type TrackingSequenceExtraArguments = {
 };
 export type Alignment = "default" | "block" | "inline-block" | "inline" | "float-left" | "float-right" | "full-width";
 type WidgetOptions = any;
-export type WidgetTransform = (arg1: WidgetOptions, problemNumber?: number) => any;
+export type WidgetTransform = (arg1: WidgetOptions, strings: PerseusStrings, problemNumber?: number) => any;
 export type WidgetExports<T extends React.ComponentType<any> = React.ComponentType<any>> = Readonly<{
     name: string;
     displayName: string;

package/dist/util/answer-types.d.ts

@@ -1,3 +1,4 @@
+import type { PerseusStrings } from "../strings";
 type Guess = any;
 type Predicate = any;
 type Score = {
@@ -8,27 +9,18 @@ type Score = {
     guess: Guess;
     ungraded?: boolean;
 };
-export declare const errors: {
-    readonly APPROXIMATED_PI_ERROR: string;
-    readonly EXTRA_SYMBOLS_ERROR: string;
-    readonly NEEDS_TO_BE_SIMPLFIED_ERROR: string;
-    readonly MISSING_PERCENT_ERROR: string;
-    readonly MULTIPLICATION_SIGN_ERROR: string;
-    readonly WRONG_CASE_ERROR: string;
-    readonly WRONG_LETTER_ERROR: string;
-};
 declare const KhanAnswerTypes: {
     readonly predicate: {
         readonly defaultForms: "integer, proper, improper, mixed, decimal";
-        readonly createValidatorFunctional: (predicate: Predicate, options: any) => (arg1: Guess) => Score;
+        readonly createValidatorFunctional: (predicate: Predicate, options: any, strings: PerseusStrings) => (arg1: Guess) => Score;
     };
     readonly number: {
         readonly convertToPredicate: (correctAnswer: string, options: any) => Predicate;
-        readonly createValidatorFunctional: (correctAnswer: string, options: any) => (arg1: Guess) => Score;
+        readonly createValidatorFunctional: (correctAnswer: string, options: any, strings: PerseusStrings) => (arg1: Guess) => Score;
     };
     readonly expression: {
         readonly parseSolution: (solutionString: string, options: any) => any;
-        readonly createValidatorFunctional: (solution: any, options: any) => (arg1: Guess) => Score;
+        readonly createValidatorFunctional: (solution: any, options: any, strings: PerseusStrings) => (arg1: Guess) => Score;
     };
 };
 export default KhanAnswerTypes;

package/dist/util.d.ts

@@ -1,5 +1,6 @@
 import * as GraphieUtil from "./util.graphie";
 import type { Range } from "./perseus-types";
+import type { PerseusStrings } from "./strings";
 import type { Widget, PerseusScore } from "./types";
 import type { KEScore } from "@khanacademy/perseus-core";
 type WordPosition = {
@@ -51,7 +52,7 @@ declare function keScoreFromPerseusScore(score: PerseusScore, guess: any, state:
  * Return the first valid interpretation of 'text' as a number, in the form
  * {value: 2.3, exact: true}.
  */
-declare function firstNumericalParse(text: string): ParsedValue | null | undefined;
+declare function firstNumericalParse(text: string, strings: PerseusStrings): ParsedValue | null | undefined;
 declare function stringArrayOfSize(size: number): ReadonlyArray<string>;
 /**
  * For a graph's x or y dimension, given the tick step,

package/dist/widgets/categorizer.d.ts

@@ -1,5 +1,7 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { PerseusCategorizerWidgetOptions } from "../perseus-types";
+import type { PerseusStrings } from "../strings";
 import type { PerseusScore, WidgetProps } from "../types";
 type UserInput = any;
 export type Rubric = PerseusCategorizerWidgetOptions;
@@ -16,6 +18,11 @@ type State = {
     uniqueId: string;
 };
 export declare class Categorizer extends React.Component<Props, State> {
+    static contextType: React.Context<{
+        strings: PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     state: State;
     change: (...args: ReadonlyArray<unknown>) => any;
@@ -23,7 +30,7 @@ export declare class Categorizer extends React.Component<Props, State> {
     render(): React.ReactNode;
     onChange(itemNum: any, catNum: any): void;
     simpleValidate: (arg1: Rubric) => PerseusScore;
-    static validate(userInput: UserInput, rubric: Rubric): PerseusScore;
+    static validate(userInput: UserInput, rubric: Rubric, strings: PerseusStrings): PerseusScore;
     static getUserInputFromProps(props: Props): UserInput;
 }
 type RenderProps = {

package/dist/widgets/definition.d.ts

@@ -1,4 +1,5 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { PerseusRenderer, PerseusDefinitionWidgetOptions } from "../perseus-types";
 import type { PerseusScore, WidgetProps } from "../types";
 type Empty = Record<never, never>;
@@ -13,6 +14,11 @@ type DefaultProps = {
     definition: string;
 };
 declare class Definition extends React.Component<DefinitionProps> {
+    static contextType: React.Context<{
+        strings: import("../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     static validate(userInput: UserInput, rubric: Rubric): PerseusScore;
     getUserInput: () => UserInput;

package/dist/widgets/deprecated-standin/index.d.ts

@@ -1,9 +1,15 @@
 import React from "react";
+import { PerseusI18nContext } from "../../components/i18n-context";
 import type { PerseusScore } from "../../types";
 type Props = any;
 type Rubric = any;
 type UserInput = Empty;
 declare class DeprecatedStandin extends React.Component<Props> {
+    static contextType: React.Context<{
+        strings: import("../../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     static validate(userInput: UserInput, rubric: Rubric): PerseusScore;
     getUserInput: () => UserInput;
     simpleValidate: (arg1: Rubric) => PerseusScore;

package/dist/widgets/explanation.d.ts

@@ -1,4 +1,5 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { PerseusExplanationWidgetOptions } from "../perseus-types";
 import type { PerseusScore, WidgetProps } from "../types";
 type Empty = Record<never, never>;
@@ -17,6 +18,11 @@ type State = {
     expanded: boolean;
 };
 declare class Explanation extends React.Component<Props, State> {
+    static contextType: React.Context<{
+        strings: import("../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     static validate(userInput: UserInput, rubric: Rubric): PerseusScore;
     state: State;

package/dist/widgets/expression.d.ts

@@ -1,6 +1,8 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { DependenciesContext } from "../dependencies";
 import type { PerseusExpressionWidgetOptions } from "../perseus-types";
+import type { PerseusStrings } from "../strings";
 import type { PerseusScore, WidgetProps } from "../types";
 import type { Keys as Key, KeypadConfiguration } from "@khanacademy/math-input";
 type InputPath = ReadonlyArray<string>;
@@ -39,9 +41,18 @@ type DefaultProps = {
     value: Props["value"];
 };
 type OnInputErrorFunctionType = (arg1?: any, arg2?: any, arg3?: any) => boolean | null | undefined;
+/**
+ *  Get the character used for separating decimals.
+ */
+export declare const getDecimalSeparator: (locale: string) => string;
 export declare class Expression extends React.Component<Props, ExpressionState> {
+    static contextType: React.Context<{
+        strings: PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     _isMounted: boolean;
-    static validate(userInput: string, rubric: Rubric, onInputError?: OnInputErrorFunctionType): PerseusScore;
+    static validate(userInput: string, rubric: Rubric, onInputError: OnInputErrorFunctionType | undefined, strings: PerseusStrings, locale: string): PerseusScore;
     static getUserInputFromProps(props: Props): string;
     static getOneCorrectAnswerFromRubric(rubric: Rubric): string | null | undefined;
     static defaultProps: DefaultProps;
@@ -124,13 +135,15 @@ declare const _default: Readonly<{
             crossOutEnabled?: boolean | undefined;
             editorChangeDelay?: number | undefined;
             flags?: {
-                mafs?: false | {
+                mafs?: false | ({
                     polygon?: boolean | undefined;
                     linear?: boolean | undefined;
+                    ray?: boolean | undefined;
                     segment?: boolean | undefined;
                     "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                } | undefined;
+                } & {
+                    "interactive-graph-locked-features-m1"?: boolean | undefined;
+                }) | undefined;
             } | undefined;
             onWidgetStartProps?: ((widgets: import("../perseus-types").PerseusWidgetsMap) => void) | undefined;
         }> & {
@@ -199,13 +212,15 @@ declare const _default: Readonly<{
             crossOutEnabled?: boolean | undefined;
             editorChangeDelay?: number | undefined;
             flags?: {
-                mafs?: false | {
+                mafs?: false | ({
                     polygon?: boolean | undefined;
                     linear?: boolean | undefined;
+                    ray?: boolean | undefined;
                     segment?: boolean | undefined;
                     "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                } | undefined;
+                } & {
+                    "interactive-graph-locked-features-m1"?: boolean | undefined;
+                }) | undefined;
             } | undefined;
             onWidgetStartProps?: ((widgets: import("../perseus-types").PerseusWidgetsMap) => void) | undefined;
         }> & {
@@ -274,13 +289,15 @@ declare const _default: Readonly<{
             crossOutEnabled?: boolean | undefined;
             editorChangeDelay?: number | undefined;
             flags?: {
-                mafs?: false | {
+                mafs?: false | ({
                     polygon?: boolean | undefined;
                     linear?: boolean | undefined;
+                    ray?: boolean | undefined;
                     segment?: boolean | undefined;
                     "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                } | undefined;
+                } & {
+                    "interactive-graph-locked-features-m1"?: boolean | undefined;
+                }) | undefined;
             } | undefined;
             onWidgetStartProps?: ((widgets: import("../perseus-types").PerseusWidgetsMap) => void) | undefined;
         }> & {
@@ -346,13 +363,15 @@ declare const _default: Readonly<{
             crossOutEnabled?: boolean | undefined;
             editorChangeDelay?: number | undefined;
             flags?: {
-                mafs?: false | {
+                mafs?: false | ({
                     polygon?: boolean | undefined;
                     linear?: boolean | undefined;
+                    ray?: boolean | undefined;
                     segment?: boolean | undefined;
                     "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                } | undefined;
+                } & {
+                    "interactive-graph-locked-features-m1"?: boolean | undefined;
+                }) | undefined;
             } | undefined;
             onWidgetStartProps?: ((widgets: import("../perseus-types").PerseusWidgetsMap) => void) | undefined;
         }> & {
@@ -421,13 +440,15 @@ declare const _default: Readonly<{
             crossOutEnabled?: boolean | undefined;
             editorChangeDelay?: number | undefined;
             flags?: {
-                mafs?: false | {
+                mafs?: false | ({
                     polygon?: boolean | undefined;
                     linear?: boolean | undefined;
+                    ray?: boolean | undefined;
                     segment?: boolean | undefined;
                     "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                } | undefined;
+                } & {
+                    "interactive-graph-locked-features-m1"?: boolean | undefined;
+                }) | undefined;
             } | undefined;
             onWidgetStartProps?: ((widgets: import("../perseus-types").PerseusWidgetsMap) => void) | undefined;
         }> & {
@@ -496,13 +517,15 @@ declare const _default: Readonly<{
             crossOutEnabled?: boolean | undefined;
             editorChangeDelay?: number | undefined;
             flags?: {
-                mafs?: false | {
+                mafs?: false | ({
                     polygon?: boolean | undefined;
                     linear?: boolean | undefined;
+                    ray?: boolean | undefined;
                     segment?: boolean | undefined;
                     "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                } | undefined;
+                } & {
+                    "interactive-graph-locked-features-m1"?: boolean | undefined;
+                }) | undefined;
             } | undefined;
             onWidgetStartProps?: ((widgets: import("../perseus-types").PerseusWidgetsMap) => void) | undefined;
         }> & {

package/dist/widgets/graded-group-answer-bar.d.ts

@@ -1,4 +1,5 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { APIOptions } from "../types";
 export type ANSWER_BAR_STATES = "HIDDEN" | "ACTIVE" | "INACTIVE" | "INCORRECT" | "CORRECT";
 type Props = {
@@ -8,6 +9,11 @@ type Props = {
     onNextQuestion?: () => unknown;
 };
 declare class GradedGroupAnswerBar extends React.Component<Props> {
+    static contextType: React.Context<{
+        strings: import("../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     render(): React.ReactNode;
 }
 export default GradedGroupAnswerBar;

package/dist/widgets/graded-group.d.ts

@@ -1,4 +1,5 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { ANSWER_BAR_STATES } from "./graded-group-answer-bar";
 import type { PerseusGradedGroupWidgetOptions } from "../perseus-types";
 import type { TrackingGradedGroupExtraArguments, WidgetProps } from "../types";
@@ -30,6 +31,11 @@ type State = {
     answerBarState: ANSWER_BAR_STATES;
 };
 export declare class GradedGroup extends React.Component<Props, State> {
+    static contextType: React.Context<{
+        strings: import("../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     state: State;
     shouldComponentUpdate(nextProps: Props, nextState: State): boolean;

package/dist/widgets/group.d.ts

@@ -1,4 +1,5 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import Renderer from "../renderer";
 import type { PerseusGroupWidgetOptions } from "../perseus-types";
 import type { ChangeFn, FocusPath, PerseusScore, WidgetProps } from "../types";
@@ -12,6 +13,11 @@ type DefaultProps = {
     linterContext: Props["linterContext"];
 };
 declare class Group extends React.Component<Props> {
+    static contextType: React.Context<{
+        strings: import("../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     rendererRef: Renderer | null | undefined;
     static defaultProps: DefaultProps;
     componentDidMount(): void;

package/dist/widgets/image.d.ts

@@ -1,4 +1,5 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { PerseusImageWidgetOptions } from "../perseus-types";
 import type { ChangeFn, PerseusScore, WidgetProps } from "../types";
 type RenderProps = PerseusImageWidgetOptions;
@@ -28,6 +29,11 @@ type DefaultProps = {
     linterContext: Props["linterContext"];
 };
 declare class ImageWidget extends React.Component<Props> {
+    static contextType: React.Context<{
+        strings: import("../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     change: ChangeFn;
     getUserInput: () => UserInput;

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

@@ -1,5 +1,7 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { PerseusInputNumberWidgetOptions } from "../perseus-types";
+import type { PerseusStrings } from "../strings";
 import type { APIOptions, Path, PerseusScore, WidgetProps } from "../types";
 type UserInput = {
     currentValue: string;
@@ -29,6 +31,11 @@ type DefaultProps = {
     size: Props["size"];
 };
 declare class InputNumber extends React.Component<Props> {
+    static contextType: React.Context<{
+        strings: PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     shouldShowExamples: () => boolean;
     render(): React.ReactNode;
@@ -46,7 +53,7 @@ declare class InputNumber extends React.Component<Props> {
     examples: () => ReadonlyArray<string>;
     static validate(state: {
         currentValue: string;
-    }, rubric: Rubric, onInputError?: APIOptions["onInputError"]): PerseusScore;
+    }, rubric: Rubric, strings: PerseusStrings, onInputError?: APIOptions["onInputError"]): PerseusScore;
     static getUserInputFromProps(props: Props): {
         currentValue: string;
     };

package/dist/widgets/interactive-graph.d.ts

@@ -1,4 +1,5 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { Coord } from "../interactive2/types";
 import type { PerseusGraphType, PerseusGraphTypeAngle, PerseusGraphTypePoint, PerseusGraphTypePolygon, PerseusGraphTypeSegment, PerseusInteractiveGraphWidgetOptions } from "../perseus-types";
 import type { Widget } from "../renderer";
@@ -25,6 +26,11 @@ type DefaultProps = {
     graph: Props["graph"];
 };
 declare class LegacyInteractiveGraph extends React.Component<Props, State> {
+    static contextType: React.Context<{
+        strings: import("../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     angle: any | null | undefined;
     circle: any | null | undefined;
     graphie: any | null | undefined;

package/dist/widgets/interactive-graphs/interactive-graph-question-builder.d.ts

@@ -0,0 +1,21 @@
+import type { PerseusRenderer } from "../../perseus-types";
+import type { Interval, vec } from "mafs";
+export declare function interactiveGraphQuestionBuilder(): InteractiveGraphQuestionBuilder;
+declare class InteractiveGraphQuestionBuilder {
+    gridStep: vec.Vector2;
+    labels: [string, string];
+    markings: "graph" | "grid" | "none";
+    xRange: Interval;
+    yRange: Interval;
+    snapStep: vec.Vector2;
+    tickStep: vec.Vector2;
+    build(): PerseusRenderer;
+    withGridStep(x: number, y: number): InteractiveGraphQuestionBuilder;
+    withAxisLabels(x: string, y: string): InteractiveGraphQuestionBuilder;
+    withMarkings(markings: "graph" | "grid" | "none"): InteractiveGraphQuestionBuilder;
+    withXRange(min: number, max: number): InteractiveGraphQuestionBuilder;
+    withYRange(min: number, max: number): InteractiveGraphQuestionBuilder;
+    withSnapStep(x: number, y: number): InteractiveGraphQuestionBuilder;
+    withTickStep(x: number, y: number): InteractiveGraphQuestionBuilder;
+}
+export {};

package/dist/widgets/interactive-graphs/locked-line.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { LockedLineType } from "../../perseus-types";
+declare const LockedLine: (props: LockedLineType) => JSX.Element | null;
+export default LockedLine;

package/dist/widgets/interactive-graphs/locked-point.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { type LockedPointType } from "../../perseus-types";
+declare const LockedPoint: (props: LockedPointType) => JSX.Element;
+export default LockedPoint;

package/dist/widgets/interactive-graphs/mafs-graph.d.ts

@@ -16,6 +16,7 @@ export type Props = {
     containerSizeClass: InteractiveGraphProps["containerSizeClass"];
     markings: InteractiveGraphProps["markings"];
     onChange: InteractiveGraphProps["onChange"];
+    showTooltips: Required<InteractiveGraphProps["showTooltips"]>;
 };
 export declare const StatefulMafsGraph: React.ForwardRefExoticComponent<Props & React.RefAttributes<Partial<Widget>>>;
 type MafsGraphProps = Props & {

package/dist/widgets/interactive-graphs/reducer/use-graph-config.d.ts

@@ -4,6 +4,7 @@ type GraphConfig = {
     range: [Interval, Interval];
     snapStep: vec.Vector2;
     markings: "graph" | "grid" | "none";
+    showTooltips: boolean;
 };
 export declare const GraphConfigContext: React.Context<GraphConfig>;
 export default function useGraphConfig(): GraphConfig;

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

@@ -5,6 +5,7 @@
  */
 /// <reference path="../../../types/aphrodite.d.ts" />
 import * as React from "react";
+import { PerseusI18nContext } from "../../components/i18n-context";
 import type { InteractiveMarkerType } from "./types";
 import type { AnalyticsEventHandlerFn } from "@khanacademy/perseus-core";
 import type { CSSProperties } from "aphrodite";
@@ -21,6 +22,11 @@ type Props = InteractiveMarkerType & {
     hovered: boolean;
 };
 export default class Marker extends React.Component<Props> {
+    static contextType: React.Context<{
+        strings: import("../../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     _icon: HTMLElement | null | undefined;
     static defaultProps: {
         selected: ReadonlyArray<any>;

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

@@ -6,6 +6,7 @@
  * knowledge by directly interacting with the image.
  */
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import Marker from "./label-image/marker";
 import type { InteractiveMarkerType, InteractiveMarkerScore } from "./label-image/types";
 import type { DependencyProps } from "../dependencies";
@@ -52,6 +53,11 @@ type LabelImageState = {
     hideAnswers: boolean;
 };
 export declare class LabelImage extends React.Component<LabelImageProps, LabelImageState> {
+    static contextType: React.Context<{
+        strings: import("../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     _markers: Array<Marker | null | undefined>;
     static gradeMarker(marker: InteractiveMarkerType): InteractiveMarkerScore;
     static validate(state: MarkersState, rubric?: LabelImageProps): PerseusScore;
@@ -123,13 +129,15 @@ declare const _default: Readonly<{
             crossOutEnabled?: boolean | undefined;
             editorChangeDelay?: number | undefined;
             flags?: {
-                mafs?: false | {
+                mafs?: false | ({
                     polygon?: boolean | undefined;
                     linear?: boolean | undefined;
+                    ray?: boolean | undefined;
                     segment?: boolean | undefined;
                     "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                } | undefined;
+                } & {
+                    "interactive-graph-locked-features-m1"?: boolean | undefined;
+                }) | undefined;
             } | undefined;
             onWidgetStartProps?: ((widgets: import("..").PerseusWidgetsMap) => void) | undefined;
         }>;
@@ -180,13 +188,15 @@ declare const _default: Readonly<{
             crossOutEnabled?: boolean | undefined;
             editorChangeDelay?: number | undefined;
             flags?: {
-                mafs?: false | {
+                mafs?: false | ({
                     polygon?: boolean | undefined;
                     linear?: boolean | undefined;
+                    ray?: boolean | undefined;
                     segment?: boolean | undefined;
                     "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                } | undefined;
+                } & {
+                    "interactive-graph-locked-features-m1"?: boolean | undefined;
+                }) | undefined;
             } | undefined;
             onWidgetStartProps?: ((widgets: import("..").PerseusWidgetsMap) => void) | undefined;
         }>;

package/dist/widgets/matcher.d.ts

@@ -1,5 +1,6 @@
 import PropTypes from "prop-types";
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { SortableOption } from "../components/sortable";
 type State = {
     leftHeight: number;
@@ -7,6 +8,11 @@ type State = {
     texRendererLoaded: boolean;
 };
 export declare class Matcher extends React.Component<any, any> {
+    static contextType: React.Context<{
+        strings: import("../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     static propTypes: {
         apiOptions: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
             isArticle: PropTypes.Validator<boolean>;

package/dist/widgets/matrix.d.ts

@@ -1,6 +1,8 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { PerseusMatrixWidgetOptions } from "../perseus-types";
-import type { WidgetProps } from "../types";
+import type { PerseusStrings } from "../strings";
+import type { WidgetProps, PerseusScore } from "../types";
 type Rubric = PerseusMatrixWidgetOptions;
 type ExternalProps = WidgetProps<PerseusMatrixWidgetOptions, Rubric>;
 type Props = ExternalProps & {
@@ -23,8 +25,14 @@ type State = {
     enterTheMatrix: number;
 };
 declare class Matrix extends React.Component<Props, State> {
+    static contextType: React.Context<{
+        strings: PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     cursorPosition: [number, number];
     static defaultProps: DefaultProps;
+    static validate(state: any, rubric: any, strings: PerseusStrings): PerseusScore;
     state: State;
     componentDidMount(): void;
     render(): React.ReactNode;

package/dist/widgets/molecule.d.ts

@@ -1,4 +1,5 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../components/i18n-context";
 import type { PerseusMoleculeRendererWidgetOptions } from "../perseus-types";
 type MoleculeState = {
     parsedSmiles: any;
@@ -10,6 +11,11 @@ type Props = {
     rotationAngle: PerseusMoleculeRendererWidgetOptions["rotationAngle"];
 };
 export declare class Molecule extends React.Component<Props, MoleculeState> {
+    static contextType: React.Context<{
+        strings: import("../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     state: MoleculeState;
     UNSAFE_componentWillMount(): void;
     componentDidMount(): void;