@step-wise/input-exercises 0.1.0

package/dist/InputExercise/reducerSupport.d.ts

@@ -0,0 +1,41 @@
+import { type ExerciseAction, type ExerciseMode, type ExerciseState, type UpdateSkills } from '@step-wise/exercise-definition';
+import type { SerializedData } from '@step-wise/serialization';
+import type { InputDependency, InputExerciseParameters, InputExerciseReport, InputExerciseValueOperations } from './types.ts';
+export type SoloInputExerciseDependencyState = Partial<{
+    inputDependency: SerializedData;
+}>;
+export type GroupInputExerciseDependencyState = Partial<{
+    inputDependencies: Record<string, SerializedData>;
+}>;
+export type InputExerciseDependencyState = SoloInputExerciseDependencyState & GroupInputExerciseDependencyState;
+export type SoloInputExerciseAttemptState = Partial<{
+    attempted: true;
+}>;
+export type GroupInputExerciseAttemptState = Partial<{
+    attemptedBy: string[];
+}>;
+export type InputExerciseAttemptState = SoloInputExerciseAttemptState & GroupInputExerciseAttemptState;
+type InputExerciseUserAction<TAction extends ExerciseAction> = {
+    userId?: string;
+    action: TAction;
+};
+export type InputExerciseReducerInput<TAction extends ExerciseAction, TState extends ExerciseState, TParameters extends InputExerciseParameters> = {
+    mode: ExerciseMode;
+    actions: readonly InputExerciseUserAction<TAction>[];
+    parameters: TParameters;
+    state: TState;
+    updateSkills?: UpdateSkills;
+};
+export type InputExerciseActionsReduction<TState extends ExerciseState> = {
+    state: TState;
+    reports: (InputExerciseReport | undefined)[];
+};
+export declare function hasAttempted(state: InputExerciseAttemptState, mode: ExerciseMode, userId?: string): boolean;
+export declare function addAttemptsToState<TState extends InputExerciseAttemptState>(state: TState, mode: ExerciseMode, userIds: readonly (string | undefined)[]): TState;
+export declare function getInputDependency<TInputDependency = InputDependency>(state: InputExerciseDependencyState, mode: ExerciseMode, valueOperations: InputExerciseValueOperations, userId?: string): TInputDependency | undefined;
+export declare function setInputDependencies<TState extends InputExerciseDependencyState>(state: TState, mode: ExerciseMode, dependencies: readonly {
+    userId?: string;
+    value: unknown;
+}[], valueOperations: InputExerciseValueOperations): TState;
+export {};
+//# sourceMappingURL=reducerSupport.d.ts.map

package/dist/InputExercise/reducerSupport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducerSupport.d.ts","sourceRoot":"","sources":["../../src/InputExercise/reducerSupport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAgC,MAAM,gCAAgC,CAAA;AAC5J,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAE9D,OAAO,KAAK,EAAE,eAAe,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAA;AAG7H,MAAM,MAAM,gCAAgC,GAAG,OAAO,CAAC;IAAE,eAAe,EAAE,cAAc,CAAA;CAAE,CAAC,CAAA;AAC3F,MAAM,MAAM,iCAAiC,GAAG,OAAO,CAAC;IAAE,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;CAAE,CAAC,CAAA;AAC9G,MAAM,MAAM,4BAA4B,GAAG,gCAAgC,GAAG,iCAAiC,CAAA;AAG/G,MAAM,MAAM,6BAA6B,GAAG,OAAO,CAAC;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AACxE,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAAA;AAC/E,MAAM,MAAM,yBAAyB,GAAG,6BAA6B,GAAG,8BAA8B,CAAA;AAGtG,KAAK,uBAAuB,CAAC,OAAO,SAAS,cAAc,IAAI;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;CACf,CAAA;AACD,MAAM,MAAM,yBAAyB,CAAC,OAAO,SAAS,cAAc,EAAE,MAAM,SAAS,aAAa,EAAE,WAAW,SAAS,uBAAuB,IAAI;IAClJ,IAAI,EAAE,YAAY,CAAA;IAClB,OAAO,EAAE,SAAS,uBAAuB,CAAC,OAAO,CAAC,EAAE,CAAA;IACpD,UAAU,EAAE,WAAW,CAAA;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,YAAY,CAAC,EAAE,YAAY,CAAA;CAC3B,CAAA;AAGD,MAAM,MAAM,6BAA6B,CAAC,MAAM,SAAS,aAAa,IAAI;IACzE,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,CAAC,mBAAmB,GAAG,SAAS,CAAC,EAAE,CAAA;CAC5C,CAAA;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,yBAAyB,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAY3G;AAGD,wBAAgB,kBAAkB,CAAC,MAAM,SAAS,yBAAyB,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GAAG,MAAM,CAkBhK;AAGD,wBAAgB,kBAAkB,CAAC,gBAAgB,GAAG,eAAe,EAAE,KAAK,EAAE,4BAA4B,EAAE,IAAI,EAAE,YAAY,EAAE,eAAe,EAAE,4BAA4B,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAe5N;AAGD,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,4BAA4B,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAAE,EAAE,eAAe,EAAE,4BAA4B,GAAG,MAAM,CAyBxO"}

package/dist/InputExercise/reducerSupport.js

@@ -0,0 +1,82 @@
+import { throwUnsupportedExerciseMode } from '@step-wise/exercise-definition';
+// Check in the state if a user has attempted an exercise (or step).
+export function hasAttempted(state, mode, userId) {
+    switch (mode) {
+        case 'solo':
+            return state.attempted === true;
+        case 'group':
+            if (userId === undefined)
+                throw new TypeError(`A userId is required when checking attempts for a group exercise.`);
+            return state.attemptedBy?.includes(userId) ?? false;
+        default:
+            return throwUnsupportedExerciseMode(mode);
+    }
+}
+// Update the state to note that the given users attempted the exercise (or step).
+export function addAttemptsToState(state, mode, userIds) {
+    if (userIds.length === 0)
+        return state;
+    switch (mode) {
+        case 'solo':
+            return { ...state, attempted: true };
+        case 'group': {
+            const attemptedBy = new Set(state.attemptedBy);
+            userIds.forEach(userId => {
+                if (userId === undefined)
+                    throw new TypeError(`A userId is required when registering an attempt for a group exercise.`);
+                attemptedBy.add(userId);
+            });
+            return { ...state, attemptedBy: [...attemptedBy] };
+        }
+        default:
+            return throwUnsupportedExerciseMode(mode);
+    }
+}
+// Get the input dependency for the given user (or solo) from the state, deserializing it for use.
+export function getInputDependency(state, mode, valueOperations, userId) {
+    switch (mode) {
+        case 'solo':
+            return state.inputDependency === undefined ? undefined : valueOperations.deserialize(state.inputDependency);
+        case 'group': {
+            if (userId === undefined)
+                throw new TypeError(`A userId is required when getting an input dependency for a group exercise.`);
+            const userDependency = state.inputDependencies?.[userId];
+            if (userDependency !== undefined)
+                return valueOperations.deserialize(userDependency);
+            return undefined;
+        }
+        default:
+            return throwUnsupportedExerciseMode(mode);
+    }
+}
+// Apply the given input dependencies to the state, serializing them for storage.
+export function setInputDependencies(state, mode, dependencies, valueOperations) {
+    if (dependencies.length === 0)
+        return state;
+    switch (mode) {
+        case 'solo': {
+            const { inputDependency: _, ...stateWithoutDependency } = state;
+            if (dependencies.length > 1)
+                throw new TypeError(`Only one input dependency can be set for a solo exercise.`);
+            const dependency = dependencies[0].value;
+            return (dependency === undefined ? stateWithoutDependency : { ...stateWithoutDependency, inputDependency: valueOperations.serialize(dependency) });
+        }
+        case 'group': {
+            const inputDependencies = { ...state.inputDependencies };
+            dependencies.forEach(({ userId, value }) => {
+                if (userId === undefined)
+                    throw new TypeError(`A userId is required when setting an input dependency for a group exercise.`);
+                if (value === undefined)
+                    delete inputDependencies[userId];
+                else
+                    inputDependencies[userId] = valueOperations.serialize(value);
+            });
+            if (Object.keys(inputDependencies).length > 0)
+                return { ...state, inputDependencies };
+            const { inputDependencies: _, ...stateWithoutInputDependencies } = state;
+            return stateWithoutInputDependencies;
+        }
+        default:
+            return throwUnsupportedExerciseMode(mode);
+    }
+}

package/dist/InputExercise/solutions.d.ts

@@ -0,0 +1,7 @@
+import type { InputDependency, InputExerciseMetadata, InputExerciseParameters, InputExerciseSolution, InputExerciseSpec, UpdateInputDependencyData } from './types.ts';
+type SolutionCallbacks<TParameters extends InputExerciseParameters, TSolution extends InputExerciseSolution, TInputDependency> = Pick<InputExerciseSpec<InputExerciseMetadata, TParameters, TSolution, TInputDependency>, 'getStaticSolution' | 'updateInputDependency' | 'getSolution'>;
+export declare function resolveStaticSolution<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency>(definition: SolutionCallbacks<TParameters, TSolution, TInputDependency>, parameters: TParameters): Promise<Partial<TSolution>>;
+export declare function resolveUpdatedInputDependency<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency>(definition: SolutionCallbacks<TParameters, TSolution, TInputDependency>, data: UpdateInputDependencyData<TParameters, TSolution, TInputDependency>): Promise<TInputDependency | undefined>;
+export declare function resolveSolution<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency>(definition: SolutionCallbacks<TParameters, TSolution, TInputDependency>, parameters: TParameters, inputDependency: TInputDependency | undefined, staticSolution: Partial<TSolution>): Promise<TSolution | undefined>;
+export {};
+//# sourceMappingURL=solutions.d.ts.map

package/dist/InputExercise/solutions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solutions.d.ts","sourceRoot":"","sources":["../../src/InputExercise/solutions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAEtK,KAAK,iBAAiB,CACrB,WAAW,SAAS,uBAAuB,EAC3C,SAAS,SAAS,qBAAqB,EAAE,gBAAgB,IAAI,IAAI,CAAC,iBAAiB,CAAC,qBAAqB,EAAE,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,EAAE,mBAAmB,GAAG,uBAAuB,GAAG,aAAa,CAClN,CAAA;AAGF,wBAAsB,qBAAqB,CAC1C,WAAW,SAAS,uBAAuB,GAAG,uBAAuB,EACrE,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,EAC/D,gBAAgB,GAAG,eAAe,EAElC,UAAU,EAAE,iBAAiB,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,EACvE,UAAU,EAAE,WAAW,GACrB,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAE7B;AAGD,wBAAsB,6BAA6B,CAClD,WAAW,SAAS,uBAAuB,GAAG,uBAAuB,EACrE,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,EAC/D,gBAAgB,GAAG,eAAe,EAElC,UAAU,EAAE,iBAAiB,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,EACvE,IAAI,EAAE,yBAAyB,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,GACvE,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAEvC;AAGD,wBAAsB,eAAe,CACpC,WAAW,SAAS,uBAAuB,GAAG,uBAAuB,EACrE,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,EAC/D,gBAAgB,GAAG,eAAe,EAElC,UAAU,EAAE,iBAAiB,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,EACvE,UAAU,EAAE,WAAW,EACvB,eAAe,EAAE,gBAAgB,GAAG,SAAS,EAC7C,cAAc,EAAE,OAAO,CAAC,SAAS,CAAC,GAChC,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAIhC"}

package/dist/InputExercise/solutions.js

@@ -0,0 +1,15 @@
+// Resolve the reusable input-independent portion of a solution.
+export async function resolveStaticSolution(definition, parameters) {
+    return definition.getStaticSolution === undefined ? {} : await definition.getStaticSolution(parameters);
+}
+// Update the dependency with the input submitted for the current exercise step.
+export async function resolveUpdatedInputDependency(definition, data) {
+    return definition.updateInputDependency === undefined ? data.previousInputDependency : await definition.updateInputDependency(data);
+}
+// Resolve the complete solution by combining its static and dynamic portions.
+export async function resolveSolution(definition, parameters, inputDependency, staticSolution) {
+    if (definition.getSolution === undefined)
+        return undefined;
+    const dynamicSolution = await definition.getSolution(parameters, inputDependency, staticSolution);
+    return { ...staticSolution, ...dynamicSolution };
+}

package/dist/InputExercise/types.d.ts

@@ -0,0 +1,70 @@
+import type { Awaitable, PlainDataObject } from '@step-wise/js-utils';
+import type { Exercise, ExerciseMetadata, ExerciseState, GroupExerciseReducer, SoloExerciseReducer } from '@step-wise/exercise-definition';
+import type { SerializedData } from '@step-wise/serialization';
+import type { InputValue } from '@step-wise/input-interpretation';
+import type { ValueTypes } from '@step-wise/value-types';
+export type InputExerciseMetadata = ExerciseMetadata & {
+    comparisons?: Record<string, unknown>;
+};
+export type InputExerciseRawInput = Record<string, InputValue>;
+export type InputExerciseAction = {
+    type: 'input';
+    input: InputExerciseRawInput;
+    adoptUserHistory?: string;
+} | {
+    type: 'giveUp';
+};
+export type InputExerciseActionType = InputExerciseAction['type'];
+export type InputExerciseParameters = Record<string, unknown>;
+export type InputExerciseInput = Record<string, unknown>;
+export type InputExerciseReport = PlainDataObject;
+export type SoloInputExerciseReport = InputExerciseReport;
+export type GroupInputExerciseReport = Record<string, InputExerciseReport>;
+export type CheckInputResult = boolean | {
+    correct: boolean;
+    report?: InputExerciseReport;
+};
+export type InputDependency = unknown;
+export type UpdateInputDependencyData<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency> = {
+    parameters: TParameters;
+    previousInputDependency: TInputDependency | undefined;
+    staticSolution: Partial<TSolution>;
+    input: InputExerciseInput;
+    step: number;
+};
+export type UpdateInputDependency<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency> = (data: UpdateInputDependencyData<TParameters, TSolution, TInputDependency>) => Awaitable<TInputDependency | undefined>;
+export type InputExerciseSolution = Record<string, unknown>;
+export type GetStaticSolution<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution> = (parameters: TParameters) => Awaitable<Partial<TSolution>>;
+export type GetSolution<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency> = (parameters: TParameters, inputDependency: TInputDependency | undefined, staticSolution: Partial<TSolution>) => Awaitable<Partial<TSolution>>;
+export type InputExerciseSpec<TMetadata extends InputExerciseMetadata, TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency> = {
+    metadata: TMetadata;
+    valueTypes?: ValueTypes;
+    generateParameters?: (example: boolean) => Awaitable<TParameters>;
+    updateInputDependency?: UpdateInputDependency<TParameters, TSolution, TInputDependency>;
+    getStaticSolution?: GetStaticSolution<TParameters, TSolution>;
+    getSolution?: GetSolution<TParameters, TSolution, TInputDependency>;
+};
+export type InputExerciseValueOperations = {
+    serialize: (value: unknown) => SerializedData;
+    deserialize: (value: unknown) => unknown;
+    interpretInput: (input: InputExerciseRawInput) => InputExerciseInput;
+    toInputValue: (value: unknown, type: string) => InputValue;
+    areValuesEqual: (type: string, inputValue: unknown, expectedValue: unknown, options?: unknown) => boolean;
+};
+export type InputExercise<TMetadata extends InputExerciseMetadata, TAction extends InputExerciseAction, TState extends ExerciseState, TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency> = Exercise<TMetadata, TAction, TState, PlainDataObject, SoloInputExerciseReport, GroupInputExerciseReport> & Omit<InputExerciseSpec<TMetadata, TParameters, TSolution, TInputDependency>, 'generateParameters' | 'valueTypes'> & {
+    valueOperations: InputExerciseValueOperations;
+    generateParameters: (example: boolean) => Promise<PlainDataObject>;
+    getInitialState: (parameters: PlainDataObject) => Awaitable<TState>;
+    processSoloAction: SoloExerciseReducer<TAction, TState, PlainDataObject, SoloInputExerciseReport>;
+    processGroupActions: GroupExerciseReducer<TAction, TState, PlainDataObject, GroupInputExerciseReport>;
+};
+export type CheckInputData<TMetadata extends InputExerciseMetadata = InputExerciseMetadata, TParameters extends InputExerciseParameters = InputExerciseParameters, TInputDependency = InputDependency, TSolution extends InputExerciseSolution = InputExerciseSolution> = {
+    metadata: TMetadata;
+    parameters: TParameters;
+    rawInput: InputExerciseRawInput;
+    input: InputExerciseInput;
+    inputDependency: TInputDependency | undefined;
+    solution?: TSolution;
+    areValuesEqual: InputExerciseValueOperations['areValuesEqual'];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/InputExercise/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/InputExercise/types.ts"],"names":[],"mappings":"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"}

package/dist/InputExercise/types.js

@@ -0,0 +1 @@
+export {};

package/dist/InputExercise/valueOperations.d.ts

@@ -0,0 +1,4 @@
+import { type ValueTypes } from '@step-wise/value-types';
+import type { InputExerciseValueOperations } from './types.ts';
+export declare function createInputExerciseValueOperations(valueTypes?: ValueTypes): InputExerciseValueOperations;
+//# sourceMappingURL=valueOperations.d.ts.map

package/dist/InputExercise/valueOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueOperations.d.ts","sourceRoot":"","sources":["../../src/InputExercise/valueOperations.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,UAAU,EAAsE,MAAM,wBAAwB,CAAA;AAE5H,OAAO,KAAK,EAAsB,4BAA4B,EAAE,MAAM,YAAY,CAAA;AAElF,wBAAgB,kCAAkC,CAAC,UAAU,GAAE,UAAe,GAAG,4BAA4B,CAS5G"}

package/dist/InputExercise/valueOperations.js

@@ -0,0 +1,14 @@
+import { deserializeData, serializeData } from '@step-wise/serialization';
+import { interpretInputData, toInputValue } from '@step-wise/input-interpretation';
+import { createAreValuesEqual } from '@step-wise/value-equality';
+import { combineValueTypes, extractValueTypeAdapters, fundamentalValueTypes } from '@step-wise/value-types';
+export function createInputExerciseValueOperations(valueTypes = {}) {
+    const adapters = extractValueTypeAdapters(combineValueTypes(fundamentalValueTypes, valueTypes));
+    return {
+        serialize: value => serializeData(value, adapters.serializationAdapters),
+        deserialize: value => deserializeData(value, adapters.serializationAdapters),
+        interpretInput: input => interpretInputData(input, adapters.inputValueAdapters),
+        toInputValue: (value, type) => toInputValue(value, type, adapters.inputValueAdapters),
+        areValuesEqual: createAreValuesEqual(adapters.equalityAdapters),
+    };
+}

package/dist/MonoExercise/guards.d.ts

@@ -0,0 +1,3 @@
+import type { MonoExercise } from './types.ts';
+export declare function isMonoExercise(value: unknown): value is MonoExercise<any, any>;
+//# sourceMappingURL=guards.d.ts.map

package/dist/MonoExercise/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/MonoExercise/guards.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAE9E"}

package/dist/MonoExercise/guards.js

@@ -0,0 +1,4 @@
+import { hasInputExerciseProperties } from '../InputExercise/guards.js';
+export function isMonoExercise(value) {
+    return hasInputExerciseProperties(value) && value.type === 'mono';
+}

package/dist/MonoExercise/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.ts';
+export * from './guards.ts';
+export * from './reducer.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/MonoExercise/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/MonoExercise/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA"}

package/dist/MonoExercise/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './guards.js';
+export * from './reducer.js';

package/dist/MonoExercise/reducer.d.ts

@@ -0,0 +1,4 @@
+import { type InputDependency, type InputExerciseParameters, type InputExerciseSolution } from '../InputExercise/index.ts';
+import type { MonoExercise, MonoExerciseSpec } from './types.ts';
+export declare function buildMonoExercise<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency>(spec: MonoExerciseSpec<TParameters, TSolution, TInputDependency>): MonoExercise<TParameters, TSolution, TInputDependency>;
+//# sourceMappingURL=reducer.d.ts.map

package/dist/MonoExercise/reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/MonoExercise/reducer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiC,KAAK,eAAe,EAA4B,KAAK,uBAAuB,EAAE,KAAK,qBAAqB,EAA0I,MAAM,2BAA2B,CAAA;AAM3T,OAAO,KAAK,EAAqB,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAGnF,wBAAgB,iBAAiB,CAAC,WAAW,SAAS,uBAAuB,GAAG,uBAAuB,EAAE,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,EAAE,gBAAgB,GAAG,eAAe,EAAE,IAAI,EAAE,gBAAgB,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,GAAG,YAAY,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,CAYtU"}

package/dist/MonoExercise/reducer.js

@@ -0,0 +1,87 @@
+import { resolveExerciseParameters } from '@step-wise/exercise-definition';
+import { resolveSolution, resolveStaticSolution, resolveUpdatedInputDependency } from '../InputExercise/index.js';
+import { getGroupInputExerciseReport, normalizeCheckInputResult } from '../InputExercise/checkInput.js';
+import { deserializeInputExerciseParameters, serializeInputExerciseParameters } from '../InputExercise/parameterSerialization.js';
+import { createInputExerciseValueOperations } from '../InputExercise/valueOperations.js';
+import { addAttemptsToState, getInputDependency, hasAttempted, setInputDependencies } from '../InputExercise/reducerSupport.js';
+// Build a MonoExercise from its author-facing spec.
+export function buildMonoExercise(spec) {
+    const { valueTypes, ...definition } = spec;
+    const valueOperations = createInputExerciseValueOperations(valueTypes);
+    return {
+        ...definition,
+        valueOperations,
+        type: 'mono',
+        generateParameters: async (example) => serializeInputExerciseParameters(await resolveExerciseParameters(spec.generateParameters, example), valueOperations.serialize),
+        getInitialState: () => ({}),
+        processSoloAction: buildMonoExerciseSoloReducer(spec, valueOperations),
+        processGroupActions: buildMonoExerciseGroupReducer(spec, valueOperations),
+    };
+}
+// Build the solo reducer for a MonoExercise, which processes actions for a single user.
+function buildMonoExerciseSoloReducer(spec, valueOperations) {
+    return async (reducerInput) => {
+        const runtimeInput = { ...reducerInput, parameters: deserializeInputExerciseParameters(reducerInput.parameters, valueOperations.deserialize) };
+        if ('done' in runtimeInput.state && runtimeInput.state.done)
+            return { state: runtimeInput.state };
+        const { state, reports } = await reduceActions(spec, { ...runtimeInput, mode: 'solo', actions: [{ action: reducerInput.action }] }, valueOperations);
+        return reports[0] === undefined ? { state } : { state, report: reports[0] };
+    };
+}
+// Build the group reducer for a MonoExercise, which processes actions from multiple users.
+function buildMonoExerciseGroupReducer(spec, valueOperations) {
+    return async (reducerInput) => {
+        if (reducerInput.actions.length === 0)
+            throw new Error(`Cannot resolve a group exercise without actions.`);
+        const runtimeInput = { ...reducerInput, parameters: deserializeInputExerciseParameters(reducerInput.parameters, valueOperations.deserialize), mode: 'group' };
+        if ('done' in runtimeInput.state && runtimeInput.state.done)
+            return { state: runtimeInput.state };
+        const { state, reports } = await reduceActions(spec, runtimeInput, valueOperations);
+        const report = getGroupInputExerciseReport(reducerInput.actions.map(({ userId }) => userId), reports);
+        return report === undefined ? { state } : { state, report };
+    };
+}
+// Reduce a normalized set of solo or group actions.
+async function reduceActions(spec, reducerInput, valueOperations) {
+    const { metadata, checkInput } = spec;
+    const { mode, state, actions, parameters, updateSkills } = reducerInput;
+    let newState = addAttemptsToState(state, mode, actions.filter(userAction => userAction.action.type === 'input').map(userAction => userAction.userId));
+    // Run the checkInput function for all input actions, and also update the inputDependencies.
+    const staticSolution = actions.some(userAction => userAction.action.type === 'input') ? await resolveStaticSolution(spec, parameters) : {};
+    const results = await Promise.all(actions.map(async (userAction) => {
+        if (userAction.action.type !== 'input')
+            return { correct: false };
+        const input = valueOperations.interpretInput(userAction.action.input);
+        const previousInputDependency = getInputDependency(state, mode, valueOperations, mode === 'group' ? userAction.action.adoptUserHistory ?? userAction.userId : userAction.userId);
+        const inputDependency = await resolveUpdatedInputDependency(spec, { parameters, previousInputDependency, staticSolution, input: input, step: 0 });
+        const solution = await resolveSolution(spec, parameters, inputDependency, staticSolution);
+        const result = normalizeCheckInputResult(await checkInput({ metadata, parameters, rawInput: userAction.action.input, input, inputDependency, solution, areValuesEqual: valueOperations.areValuesEqual }));
+        return { ...result, inputDependency };
+    }));
+    if (spec.updateInputDependency !== undefined)
+        newState = setInputDependencies(newState, mode, results.flatMap((result, index) => 'inputDependency' in result ? [{ userId: actions[index].userId, value: result.inputDependency }] : []), valueOperations);
+    // Determine if the exercise is solved or given up, and update skills if applicable.
+    const correct = results.map(result => result.correct);
+    const someCorrect = correct.some(isCorrect => isCorrect);
+    const allGaveUp = actions.every(userAction => userAction.action.type === 'giveUp');
+    const isDone = someCorrect || allGaveUp;
+    if (updateSkills !== undefined) {
+        actions.forEach((userAction, index) => {
+            const { action, userId } = userAction;
+            if (action.type === 'input' || (isDone && !hasAttempted(state, mode, userId))) {
+                if (metadata.skill)
+                    updateSkills(metadata.skill, correct[index], userId);
+                if (metadata.setup)
+                    updateSkills(metadata.setup, correct[index], userId);
+            }
+        });
+    }
+    // Update the state and return it together with the reports.
+    const reports = results.map(result => 'report' in result ? result.report : undefined);
+    if (someCorrect)
+        return { state: { ...newState, solved: true, done: true }, reports };
+    else if (allGaveUp)
+        return { state: { ...newState, givenUp: true, done: true }, reports };
+    else
+        return { state: newState, reports };
+}

package/dist/MonoExercise/types.d.ts

@@ -0,0 +1,16 @@
+import type { Awaitable } from '@step-wise/js-utils';
+import type { InputExerciseMetadata, InputExerciseAction, InputExerciseAttemptState, InputExerciseDependencyState, InputExerciseParameters, CheckInputData, CheckInputResult, InputDependency, InputExercise, InputExerciseSpec, InputExerciseSolution } from '../InputExercise/index.ts';
+export type MonoExerciseMetadata = InputExerciseMetadata;
+export type MonoExerciseState = InputExerciseAttemptState & InputExerciseDependencyState & Partial<{
+    solved: true;
+    givenUp: true;
+    done: true;
+}>;
+export type MonoExerciseCheckInput<TParameters extends InputExerciseParameters = InputExerciseParameters, TInputDependency = InputDependency, TSolution extends InputExerciseSolution = InputExerciseSolution> = (data: CheckInputData<MonoExerciseMetadata, TParameters, TInputDependency, TSolution>) => Awaitable<CheckInputResult>;
+export type MonoExerciseSpec<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency> = InputExerciseSpec<MonoExerciseMetadata, TParameters, TSolution, TInputDependency> & {
+    checkInput: MonoExerciseCheckInput<TParameters, TInputDependency, TSolution>;
+};
+export type MonoExercise<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency> = InputExercise<MonoExerciseMetadata, InputExerciseAction, MonoExerciseState, TParameters, TSolution, TInputDependency> & Omit<MonoExerciseSpec<TParameters, TSolution, TInputDependency>, 'generateParameters' | 'valueTypes'> & {
+    type: 'mono';
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/MonoExercise/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/MonoExercise/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEpD,OAAO,KAAK,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,4BAA4B,EAAE,uBAAuB,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAE,aAAa,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AAEzR,MAAM,MAAM,oBAAoB,GAAG,qBAAqB,CAAA;AAGxD,MAAM,MAAM,iBAAiB,GAAG,yBAAyB,GAAG,4BAA4B,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAG/I,MAAM,MAAM,sBAAsB,CAAC,WAAW,SAAS,uBAAuB,GAAG,uBAAuB,EAAE,gBAAgB,GAAG,eAAe,EAAE,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,oBAAoB,EAAE,WAAW,EAAE,gBAAgB,EAAE,SAAS,CAAC,KAAK,SAAS,CAAC,gBAAgB,CAAC,CAAA;AAGtU,MAAM,MAAM,gBAAgB,CAAC,WAAW,SAAS,uBAAuB,GAAG,uBAAuB,EAAE,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,EAAE,gBAAgB,GAAG,eAAe,IAAI,iBAAiB,CAAC,oBAAoB,EAAE,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,GAAG;IAAE,UAAU,EAAE,sBAAsB,CAAC,WAAW,EAAE,gBAAgB,EAAE,SAAS,CAAC,CAAA;CAAE,CAAA;AAG/W,MAAM,MAAM,YAAY,CAAC,WAAW,SAAS,uBAAuB,GAAG,uBAAuB,EAAE,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,EAAE,gBAAgB,GAAG,eAAe,IAAI,aAAa,CAAC,oBAAoB,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,EAAE,oBAAoB,GAAG,YAAY,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA"}

package/dist/MonoExercise/types.js

@@ -0,0 +1 @@
+export {};

package/dist/StepExercise/guards.d.ts

@@ -0,0 +1,3 @@
+import type { StepExercise } from './types.ts';
+export declare function isStepExercise(value: unknown): value is StepExercise<any, any>;
+//# sourceMappingURL=guards.d.ts.map

package/dist/StepExercise/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/StepExercise/guards.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAE9E"}

package/dist/StepExercise/guards.js

@@ -0,0 +1,4 @@
+import { hasInputExerciseProperties } from '../InputExercise/guards.js';
+export function isStepExercise(value) {
+    return hasInputExerciseProperties(value) && value.type === 'step' && Array.isArray(value.metadata.steps);
+}

package/dist/StepExercise/history.d.ts

@@ -0,0 +1,10 @@
+import type { InputExerciseHistoryData, LastInputOptions } from '../InputExercise/history.ts';
+import type { InputExerciseInput, InputExerciseRawInput, InputExerciseValueOperations } from '../InputExercise/types.ts';
+import type { StepExerciseState } from './types.ts';
+export declare function getCurrentStep(state: StepExerciseState | Record<string, never>): number;
+export declare function getLastRawInputAtStep(instance: InputExerciseHistoryData<StepExerciseState>, step: number, userId?: string, options?: LastInputOptions): InputExerciseRawInput | undefined;
+export declare function getLastInputAtStep(exercise: {
+    valueOperations: InputExerciseValueOperations;
+}, instance: InputExerciseHistoryData<StepExerciseState>, step: number, userId?: string, options?: LastInputOptions): InputExerciseInput | undefined;
+export declare function hasPreviousInputAtStep(instance: InputExerciseHistoryData<StepExerciseState>, step: number, userId?: string): boolean;
+//# sourceMappingURL=history.d.ts.map

package/dist/StepExercise/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/StepExercise/history.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAC7F,OAAO,KAAK,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAA;AAExH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGnD,wBAAgB,cAAc,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM,CAEvF;AAGD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,wBAAwB,CAAC,iBAAiB,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,qBAAqB,GAAG,SAAS,CA8B7L;AAGD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE;IAAE,eAAe,EAAE,4BAA4B,CAAA;CAAE,EAAE,QAAQ,EAAE,wBAAwB,CAAC,iBAAiB,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,kBAAkB,GAAG,SAAS,CAGpP;AAUD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,wBAAwB,CAAC,iBAAiB,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAEpI"}

package/dist/StepExercise/history.js

@@ -0,0 +1,57 @@
+import { ensureInteger } from '@step-wise/js-utils';
+import { throwUnsupportedExerciseMode } from '@step-wise/exercise-definition';
+// Get the step which this exercise's state is at.
+export function getCurrentStep(state) {
+    return 'step' in state && typeof state.step === 'number' ? state.step : 0;
+}
+// Get the last given raw input from the user at the given step.
+export function getLastRawInputAtStep(instance, step, userId, options = {}) {
+    step = ensureInteger(step, { nonNegative: true });
+    const { resolvedOnly = false } = options;
+    const { mode } = instance;
+    switch (mode) {
+        case 'solo':
+            for (let index = instance.history.length - 1; index >= 0; index--) {
+                const userAction = instance.history[index].action;
+                if (userAction.type !== 'input')
+                    continue;
+                if (getCurrentStep(getStateBeforeEvent(instance, index)) === step)
+                    return userAction.input;
+            }
+            return undefined;
+        case 'group': {
+            if (userId === undefined)
+                throw new TypeError(`A userId is required when retrieving input from a group exercise history.`);
+            let historyUserId = userId;
+            for (let index = instance.history.length - 1; index >= 0; index--) {
+                const event = instance.history[index];
+                const userAction = event.actions.find(userAction => userAction.userId === historyUserId)?.action;
+                if (!userAction || userAction.type !== 'input')
+                    continue;
+                if ((!resolvedOnly || 'state' in event) && getCurrentStep(getStateBeforeEvent(instance, index)) === step)
+                    return userAction.input;
+                historyUserId = userAction.adoptUserHistory ?? historyUserId;
+            }
+            return undefined;
+        }
+        default:
+            return throwUnsupportedExerciseMode(mode);
+    }
+}
+// Get the last given input from the user at the given step and interpret all its values.
+export function getLastInputAtStep(exercise, instance, step, userId, options = {}) {
+    const rawInput = getLastRawInputAtStep(instance, step, userId, options);
+    return rawInput === undefined ? undefined : exercise.valueOperations.interpretInput(rawInput);
+}
+function getStateBeforeEvent(instance, eventIndex) {
+    if (eventIndex === 0)
+        return instance.initialState;
+    const previousEvent = instance.history[eventIndex - 1];
+    if (!('state' in previousEvent))
+        throw new Error(`Cannot determine the state before an event because the preceding event is unresolved.`);
+    return previousEvent.state;
+}
+// Check if a user has made a previous input at the given step.
+export function hasPreviousInputAtStep(instance, step, userId) {
+    return getLastRawInputAtStep(instance, step, userId) !== undefined;
+}

package/dist/StepExercise/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.ts';
+export * from './guards.ts';
+export { createStepExerciseMetadata } from './preprocessing.ts';
+export * from './history.ts';
+export * from './reducer.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/StepExercise/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/StepExercise/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAA;AAC/D,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA"}

package/dist/StepExercise/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './guards.js';
+export { createStepExerciseMetadata } from './preprocessing.js';
+export * from './history.js';
+export * from './reducer.js';

package/dist/StepExercise/preprocessing.d.ts

@@ -0,0 +1,8 @@
+import { type SkillSetup } from '@step-wise/skill-setup';
+import type { StepExerciseSteps } from './types.ts';
+export declare function createStepExerciseMetadata(steps: StepExerciseSteps): {
+    steps: StepExerciseSteps;
+    setup?: SkillSetup;
+};
+export declare function ensureStepExerciseSteps(steps: StepExerciseSteps): StepExerciseSteps;
+//# sourceMappingURL=preprocessing.d.ts.map

package/dist/StepExercise/preprocessing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preprocessing.d.ts","sourceRoot":"","sources":["../../src/StepExercise/preprocessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAyC,MAAM,wBAAwB,CAAA;AAE/F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGnD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,iBAAiB,GAAG;IAAE,KAAK,EAAE,iBAAiB,CAAC;IAAC,KAAK,CAAC,EAAE,UAAU,CAAA;CAAE,CAOrH;AAGD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,iBAAiB,GAAG,iBAAiB,CAMnF"}

package/dist/StepExercise/preprocessing.js

@@ -0,0 +1,27 @@
+import { ensureSetup, and } from '@step-wise/skill-setup';
+// Create the metadata for a step exercise, including the steps and the combined setup of all steps.
+export function createStepExerciseMetadata(steps) {
+    ensureStepExerciseSteps(steps);
+    const setup = getSetupFromSteps(steps);
+    return {
+        steps,
+        ...(setup === undefined ? {} : { setup }),
+    };
+}
+// Ensure that the steps are valid: an array of steps, where each step is either a SkillSetupLike or an array of SkillSetupLike with at least two substeps.
+export function ensureStepExerciseSteps(steps) {
+    if (!Array.isArray(steps))
+        throw new Error(`Invalid steps: expected an array, but received "${steps}".`);
+    steps.forEach((step, index) => {
+        if (Array.isArray(step) && step.length < 2)
+            throw new Error(`Invalid step ${index + 1}: a substep array must contain at least two substeps.`);
+    });
+    return steps;
+}
+// Get the combined setup of all steps, or undefined if no steps are defined.
+function getSetupFromSteps(steps) {
+    const definedSteps = steps.flat().filter(step => step !== undefined);
+    if (definedSteps.length === 0)
+        return undefined;
+    return and(...definedSteps.map(ensureSetup));
+}

package/dist/StepExercise/reducer.d.ts

@@ -0,0 +1,4 @@
+import { type InputDependency, type InputExerciseParameters, type InputExerciseSolution } from '../InputExercise/index.ts';
+import type { StepExercise, StepExerciseSpec } from './types.ts';
+export declare function buildStepExercise<TParameters extends InputExerciseParameters = InputExerciseParameters, TSolution extends InputExerciseSolution = InputExerciseSolution, TInputDependency = InputDependency>(spec: StepExerciseSpec<TParameters, TSolution, TInputDependency>): StepExercise<TParameters, TSolution, TInputDependency>;
+//# sourceMappingURL=reducer.d.ts.map

package/dist/StepExercise/reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/StepExercise/reducer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAiC,KAAK,eAAe,EAAqD,KAAK,uBAAuB,EAAwD,KAAK,qBAAqB,EAA0I,MAAM,2BAA2B,CAAA;AAM1Y,OAAO,KAAK,EAAoE,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAKlI,wBAAgB,iBAAiB,CAChC,WAAW,SAAS,uBAAuB,GAAG,uBAAuB,EACrE,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,EAC/D,gBAAgB,GAAG,eAAe,EAElC,IAAI,EAAE,gBAAgB,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,GAC9D,YAAY,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,CAaxD"}