@algomotion/spec 0.0.0-stage → 1.0.0-alpha.1

package/dist/kinds/kind.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The contract every structure kind implements on the protocol side
+ * (ADR 0012). The parser only talks to kinds through this interface, so a
+ * new kind (a Turing machine tape, a number line, …) is one new module plus
+ * one registry entry.
+ */
+import type { z } from 'zod';
+/** An id together with where it appears, relative to its declaration or action. */
+export interface IdRef {
+    readonly id: string;
+    readonly path: readonly PropertyKey[];
+}
+/** A structural problem in a declaration. */
+export interface DeclIssue {
+    readonly path: readonly PropertyKey[];
+    readonly message: string;
+    readonly hint?: string;
+}
+/** Services the parser offers while normalising an action. */
+export interface ActionContext {
+    /**
+     * Returns an id of the form `${prefix}${n}` that is not yet used in this
+     * structure, and reserves it. Used to give shorthand elements ids.
+     */
+    allocateId(prefix: string): string;
+}
+/** The types a kind is made of. */
+export interface KindTypes {
+    /** Canonical declaration, as renderers see it. */
+    readonly decl: {
+        readonly kind: string;
+    };
+    /** Authoring declaration; may allow shorthands. */
+    readonly declInput: {
+        readonly kind: string;
+    };
+    /** Canonical action. */
+    readonly action: {
+        readonly type: string;
+    };
+    /** Authoring action; may allow shorthands. */
+    readonly actionInput: {
+        readonly type: string;
+    };
+}
+export interface KindSpec<T extends KindTypes> {
+    readonly kind: T['decl']['kind'];
+    readonly decl: z.ZodType<T['decl']>;
+    readonly declInput: z.ZodType<T['declInput']>;
+    readonly action: z.ZodType<T['action']>;
+    readonly actionInput: z.ZodType<T['actionInput']>;
+    /** Every action `type` the kind defines, for error hints. */
+    readonly actionTypes: readonly string[];
+    /** Expands declaration shorthands into the canonical form. */
+    normalizeDecl(input: T['declInput']): T['decl'];
+    /** Ids present in a declaration; they must be unique within it. */
+    declIds(decl: T['decl']): readonly IdRef[];
+    /**
+     * Structural rules a schema cannot express, e.g. that a tree has no
+     * cycles. Returns problems with paths relative to the declaration.
+     */
+    validateDecl?(decl: T['decl']): readonly DeclIssue[];
+    /** Expands action shorthands, allocating ids where needed. */
+    normalizeAction(input: T['actionInput'], ctx: ActionContext): T['action'];
+    /** Ids an action introduces; they must not have been used before. */
+    introducedIds(action: T['action']): readonly IdRef[];
+}
+/** The action `type` literals of a discriminated union of object schemas. */
+export declare const typesOf: (union: z.ZodDiscriminatedUnion<readonly z.ZodObject<{
+    type: z.ZodLiteral<string>;
+}>[]>) => string[];
+export declare const noIds: () => readonly IdRef[];
+//# sourceMappingURL=kind.d.ts.map

package/dist/kinds/kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind.d.ts","sourceRoot":"","sources":["../../src/kinds/kind.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,mFAAmF;AACnF,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;CACvC;AAED,6CAA6C;AAC7C,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CACpC;AAED,mCAAmC;AACnC,MAAM,WAAW,SAAS;IACxB,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,wBAAwB;IACxB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,8CAA8C;IAC9C,QAAQ,CAAC,WAAW,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACjD;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,SAAS;IAC3C,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IACxC,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;IAClD,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,8DAA8D;IAC9D,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;IAChD,mEAAmE;IACnE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,KAAK,EAAE,CAAC;IAC3C;;;OAGG;IACH,YAAY,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,SAAS,EAAE,CAAC;IACrD,8DAA8D;IAC9D,eAAe,CAAC,KAAK,EAAE,CAAC,CAAC,aAAa,CAAC,EAAE,GAAG,EAAE,aAAa,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC1E,qEAAqE;IACrE,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,SAAS,KAAK,EAAE,CAAC;CACtD;AAED,6EAA6E;AAC7E,eAAO,MAAM,OAAO,GAClB,OAAO,CAAC,CAAC,qBAAqB,CAC5B,SAAS,CAAC,CAAC,SAAS,CAAC;IAAE,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,EAAE,CACvD,KACA,MAAM,EAA4D,CAAC;AAEtE,eAAO,MAAM,KAAK,QAAO,SAAS,KAAK,EAAQ,CAAC"}

package/dist/kinds/kind.js

@@ -0,0 +1,4 @@
+/** The action `type` literals of a discriminated union of object schemas. */
+export const typesOf = (union) => union.options.map((option) => option.shape.type.value);
+export const noIds = () => [];
+//# sourceMappingURL=kind.js.map

package/dist/kinds/kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind.js","sourceRoot":"","sources":["../../src/kinds/kind.ts"],"names":[],"mappings":"AAiEA,6EAA6E;AAC7E,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,KAEC,EACS,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAEtE,MAAM,CAAC,MAAM,KAAK,GAAG,GAAqB,EAAE,CAAC,EAAE,CAAC"}

package/dist/kinds/linear.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared pieces of the linear element kinds (stack, queue, linked list).
+ */
+import { z } from 'zod';
+import { Element, Scalar } from '../common.ts';
+import type { ActionContext, IdRef } from './kind.ts';
+export declare const Elements: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>>;
+/** Bare values or explicit elements; bare values get ids e0, e1, … */
+export declare const ElementsInput: z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>>, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>]>;
+export declare const normalizeElements: (input: readonly (Element | Scalar)[]) => Element[];
+export declare const Indices: z.ZodArray<z.ZodInt>;
+export declare const elementIds: (elements: readonly Element[], key?: string) => IdRef[];
+/** Gives a bare-value `element` field, if the action has one, a generated id. */
+export declare function normalizeElementField<A extends object>(action: A, ctx: ActionContext): A;
+export declare const elementFieldIds: (action: {
+    element: Element;
+}) => IdRef[];
+//# sourceMappingURL=linear.d.ts.map

package/dist/kinds/linear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear.d.ts","sourceRoot":"","sources":["../../src/kinds/linear.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,OAAO,EAA4B,MAAM,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEtD,eAAO,MAAM,QAAQ;;;mBAAoD,CAAC;AAE1E,sEAAsE;AACtE,eAAO,MAAM,aAAa;;;2GAIvB,CAAC;AAEJ,eAAO,MAAM,iBAAiB,GAC5B,OAAO,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,EAAE,KACnC,OAAO,EAC2D,CAAC;AAEtE,eAAO,MAAM,OAAO,sBAAyD,CAAC;AAE9E,eAAO,MAAM,UAAU,GACrB,UAAU,SAAS,OAAO,EAAE,EAC5B,YAAe,KACd,KAAK,EAAkE,CAAC;AAE3E,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,EACpD,MAAM,EAAE,CAAC,EACT,GAAG,EAAE,aAAa,GACjB,CAAC,CAKH;AAED,eAAO,MAAM,eAAe,GAAI,QAAQ;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,KAAG,KAAK,EAEnE,CAAC"}

package/dist/kinds/linear.js

@@ -0,0 +1,26 @@
+/**
+ * Shared pieces of the linear element kinds (stack, queue, linked list).
+ */
+import { z } from 'zod';
+import { Element, Index, isElement, LIMITS, Scalar } from "../common.js";
+export const Elements = z.array(Element).max(LIMITS.elementsPerStructure);
+/** Bare values or explicit elements; bare values get ids e0, e1, … */
+export const ElementsInput = z
+    .union([Elements, z.array(Scalar).max(LIMITS.elementsPerStructure)])
+    .describe('Initial contents: bare values like [5, 3] (ids "e0", "e1", … are generated) or elements like [{ "id": "a", "value": 5 }].');
+export const normalizeElements = (input) => input.map((x, k) => (isElement(x) ? x : { id: `e${k}`, value: x }));
+export const Indices = z.array(Index).min(1).max(LIMITS.elementsPerStructure);
+export const elementIds = (elements, key = 'initial') => elements.map((e, k) => ({ id: e.id, path: [key, k, 'id'] }));
+/** Gives a bare-value `element` field, if the action has one, a generated id. */
+export function normalizeElementField(action, ctx) {
+    if (!('element' in action))
+        return action;
+    const element = action.element;
+    if (isElement(element))
+        return action;
+    return { ...action, element: { id: ctx.allocateId('e'), value: element } };
+}
+export const elementFieldIds = (action) => [
+    { id: action.element.id, path: ['element', 'id'] },
+];
+//# sourceMappingURL=linear.js.map

package/dist/kinds/linear.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear.js","sourceRoot":"","sources":["../../src/kinds/linear.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGzE,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAE1E,sEAAsE;AACtE,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC;KAC3B,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC;KACnE,QAAQ,CACP,2HAA2H,CAC5H,CAAC;AAEJ,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,KAAoC,EACzB,EAAE,CACb,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAEtE,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAE9E,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,QAA4B,EAC5B,GAAG,GAAG,SAAS,EACN,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;AAE3E,iFAAiF;AACjF,MAAM,UAAU,qBAAqB,CACnC,MAAS,EACT,GAAkB;IAElB,IAAI,CAAC,CAAC,SAAS,IAAI,MAAM,CAAC;QAAE,OAAO,MAAM,CAAC;IAC1C,MAAM,OAAO,GAAG,MAAM,CAAC,OAAuB,CAAC;IAC/C,IAAI,SAAS,CAAC,OAAO,CAAC;QAAE,OAAO,MAAM,CAAC;IACtC,OAAO,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC;AAC7E,CAAC;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,MAA4B,EAAW,EAAE,CAAC;IACxE,EAAE,EAAE,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE;CACnD,CAAC"}

package/dist/kinds/linked-list.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The `linkedList` kind: nodes laid out in a row, with explicit `next` (and,
+ * for doubly linked lists, `prev`) pointers.
+ *
+ * Positions refer to the row, from the left (0). Links are independent of
+ * the row, so a reversal can be shown one pointer at a time. `insert` only
+ * places a node and `move` only moves one along the row (ADR 0036); wire
+ * them in with `link`, as the code being taught would.
+ *
+ * Marks: `highlight` lasts one step; `visit`, `settle` and `pointer` persist.
+ */
+import { z } from 'zod';
+import { type KindSpec } from './kind.ts';
+export declare const LinkedListDecl: z.ZodObject<{
+    initial: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>>;
+    kind: z.ZodLiteral<"linkedList">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    doubly: z.ZodOptional<z.ZodBoolean>;
+    circular: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type LinkedListDecl = z.infer<typeof LinkedListDecl>;
+export declare const LinkedListDeclInput: z.ZodObject<{
+    initial: z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>>, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>>]>;
+    kind: z.ZodLiteral<"linkedList">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    doubly: z.ZodOptional<z.ZodBoolean>;
+    circular: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type LinkedListDeclInput = z.infer<typeof LinkedListDeclInput>;
+export declare const LinkedListAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"insert">;
+    index: z.ZodInt;
+    element: z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"remove">;
+    index: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"set">;
+    index: z.ZodInt;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"move">;
+    from: z.ZodInt;
+    to: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"link">;
+    from: z.ZodInt;
+    to: z.ZodNullable<z.ZodInt>;
+    field: z.ZodOptional<z.ZodEnum<{
+        next: "next";
+        prev: "prev";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    name: z.ZodString;
+    index: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    indices: z.ZodArray<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"visit">;
+    index: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    index: z.ZodInt;
+}, z.core.$strict>], "type">;
+export type LinkedListAction = z.infer<typeof LinkedListAction>;
+export declare const LinkedListActionInput: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"insert">;
+    index: z.ZodInt;
+    element: z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"remove">;
+    index: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"set">;
+    index: z.ZodInt;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"move">;
+    from: z.ZodInt;
+    to: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"link">;
+    from: z.ZodInt;
+    to: z.ZodNullable<z.ZodInt>;
+    field: z.ZodOptional<z.ZodEnum<{
+        next: "next";
+        prev: "prev";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    name: z.ZodString;
+    index: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    indices: z.ZodArray<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"visit">;
+    index: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    index: z.ZodInt;
+}, z.core.$strict>], "type">;
+export type LinkedListActionInput = z.infer<typeof LinkedListActionInput>;
+export declare const linkedListSpec: KindSpec<{
+    decl: LinkedListDecl;
+    declInput: LinkedListDeclInput;
+    action: LinkedListAction;
+    actionInput: LinkedListActionInput;
+}>;
+//# sourceMappingURL=linked-list.d.ts.map

package/dist/kinds/linked-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linked-list.d.ts","sourceRoot":"","sources":["../../src/kinds/linked-list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,OAAO,EAAW,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAyBnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;kBAOmB,CAAC;AAC/C,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;kBAG9B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAsDtE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAmB,CAAC;AACjD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAChE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAwB,CAAC;AAC3D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC;IACpC,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,WAAW,EAAE,qBAAqB,CAAC;CACpC,CAgBA,CAAC"}

package/dist/kinds/linked-list.js

@@ -0,0 +1,95 @@
+/**
+ * The `linkedList` kind: nodes laid out in a row, with explicit `next` (and,
+ * for doubly linked lists, `prev`) pointers.
+ *
+ * Positions refer to the row, from the left (0). Links are independent of
+ * the row, so a reversal can be shown one pointer at a time. `insert` only
+ * places a node and `move` only moves one along the row (ADR 0036); wire
+ * them in with `link`, as the code being taught would.
+ *
+ * Marks: `highlight` lasts one step; `visit`, `settle` and `pointer` persist.
+ */
+import { z } from 'zod';
+import { Element, ElementInput, Index, LIMITS, Place, PointerName, Scalar, } from "../common.js";
+import { typesOf } from "./kind.js";
+import { elementFieldIds, elementIds, Elements, ElementsInput, Indices, normalizeElementField, normalizeElements, } from "./linear.js";
+const shape = {
+    kind: z.literal('linkedList'),
+    label: z.string().max(LIMITS.textLength).optional(),
+    place: Place.optional(),
+    doubly: z
+        .boolean()
+        .optional()
+        .describe('Also keep `prev` pointers (default false).'),
+    circular: z
+        .boolean()
+        .optional()
+        .describe('Link the last node back to the first (default false).'),
+};
+export const LinkedListDecl = z
+    .strictObject({
+    ...shape,
+    initial: Elements.describe('Nodes in order; each is linked to the next (and previous, if doubly linked).'),
+})
+    .describe('A singly or doubly linked list.');
+export const LinkedListDeclInput = z.strictObject({
+    ...shape,
+    initial: ElementsInput,
+});
+const Field = z.enum(['next', 'prev']);
+const actions = (element) => z.discriminatedUnion('type', [
+    z
+        .strictObject({ type: z.literal('insert'), index: Index, element })
+        .describe('Place a new, unlinked node at row position `index` (equal to the length appends). Use `link` to wire it in.'),
+    z
+        .strictObject({ type: z.literal('remove'), index: Index })
+        .describe('Remove the node at `index`; links that pointed to it become null.'),
+    z
+        .strictObject({ type: z.literal('set'), index: Index, value: Scalar })
+        .describe('Change a node value.'),
+    z
+        .strictObject({ type: z.literal('move'), from: Index, to: Index })
+        .describe('Move the node at row position `from` to position `to`; the nodes between shift one place. Links do not change: relink with `link` in the same step.'),
+    z
+        .strictObject({
+        type: z.literal('link'),
+        from: Index,
+        to: Index.nullable(),
+        field: Field.optional(),
+    })
+        .describe('Set the `field` pointer (default "next") of node `from` to node `to`, or null.'),
+    z
+        .strictObject({
+        type: z.literal('pointer'),
+        name: PointerName,
+        index: Index.nullable(),
+    })
+        .describe('Point a named pointer (e.g. "head", "curr") at a node; null removes it.'),
+    z
+        .strictObject({ type: z.literal('highlight'), indices: Indices })
+        .describe('Highlight nodes (this step only).'),
+    z
+        .strictObject({ type: z.literal('visit'), index: Index })
+        .describe('Mark a node as visited (persists).'),
+    z
+        .strictObject({ type: z.literal('settle'), index: Index })
+        .describe('Mark a node as final or found (persists).'),
+]);
+export const LinkedListAction = actions(Element);
+export const LinkedListActionInput = actions(ElementInput);
+export const linkedListSpec = {
+    kind: 'linkedList',
+    decl: LinkedListDecl,
+    declInput: LinkedListDeclInput,
+    action: LinkedListAction,
+    actionInput: LinkedListActionInput,
+    actionTypes: typesOf(LinkedListAction),
+    normalizeDecl: (input) => ({
+        ...input,
+        initial: normalizeElements(input.initial),
+    }),
+    declIds: (decl) => elementIds(decl.initial),
+    normalizeAction: (action, ctx) => normalizeElementField(action, ctx),
+    introducedIds: (action) => action.type === 'insert' ? elementFieldIds(action) : [],
+};
+//# sourceMappingURL=linked-list.js.map

package/dist/kinds/linked-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linked-list.js","sourceRoot":"","sources":["../../src/kinds/linked-list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,OAAO,EACP,YAAY,EACZ,KAAK,EACL,MAAM,EACN,KAAK,EACL,WAAW,EACX,MAAM,GACP,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,OAAO,EAAiB,MAAM,WAAW,CAAC;AACnD,OAAO,EACL,eAAe,EACf,UAAU,EACV,QAAQ,EACR,aAAa,EACb,OAAO,EACP,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAErB,MAAM,KAAK,GAAG;IACZ,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC;IAC7B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,QAAQ,EAAE;IACnD,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE;IACvB,MAAM,EAAE,CAAC;SACN,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CAAC,4CAA4C,CAAC;IACzD,QAAQ,EAAE,CAAC;SACR,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CAAC,uDAAuD,CAAC;CACrE,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC;KAC5B,YAAY,CAAC;IACZ,GAAG,KAAK;IACR,OAAO,EAAE,QAAQ,CAAC,QAAQ,CACxB,8EAA8E,CAC/E;CACF,CAAC;KACD,QAAQ,CAAC,iCAAiC,CAAC,CAAC;AAG/C,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,YAAY,CAAC;IAChD,GAAG,KAAK;IACR,OAAO,EAAE,aAAa;CACvB,CAAC,CAAC;AAGH,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAEvC,MAAM,OAAO,GAAG,CAAsB,OAAU,EAAE,EAAE,CAClD,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IAC3B,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;SAClE,QAAQ,CACP,6GAA6G,CAC9G;IACH,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;SACzD,QAAQ,CACP,mEAAmE,CACpE;IACH,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;SACrE,QAAQ,CAAC,sBAAsB,CAAC;IACnC,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;SACjE,QAAQ,CACP,qJAAqJ,CACtJ;IACH,CAAC;SACE,YAAY,CAAC;QACZ,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QACvB,IAAI,EAAE,KAAK;QACX,EAAE,EAAE,KAAK,CAAC,QAAQ,EAAE;QACpB,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE;KACxB,CAAC;SACD,QAAQ,CACP,gFAAgF,CACjF;IACH,CAAC;SACE,YAAY,CAAC;QACZ,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QAC1B,IAAI,EAAE,WAAW;QACjB,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE;KACxB,CAAC;SACD,QAAQ,CACP,yEAAyE,CAC1E;IACH,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;SAChE,QAAQ,CAAC,mCAAmC,CAAC;IAChD,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;SACxD,QAAQ,CAAC,oCAAoC,CAAC;IACjD,CAAC;SACE,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;SACzD,QAAQ,CAAC,2CAA2C,CAAC;CACzD,CAAC,CAAC;AAEL,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEjD,MAAM,CAAC,MAAM,qBAAqB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAG3D,MAAM,CAAC,MAAM,cAAc,GAKtB;IACH,IAAI,EAAE,YAAY;IAClB,IAAI,EAAE,cAAc;IACpB,SAAS,EAAE,mBAAmB;IAC9B,MAAM,EAAE,gBAAgB;IACxB,WAAW,EAAE,qBAAqB;IAClC,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC;IACtC,aAAa,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACzB,GAAG,KAAK;QACR,OAAO,EAAE,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC;KAC1C,CAAC;IACF,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC;IAC3C,eAAe,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,CAC/B,qBAAqB,CAAC,MAAM,EAAE,GAAG,CAAqB;IACxD,aAAa,EAAE,CAAC,MAAM,EAAE,EAAE,CACxB,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE;CAC1D,CAAC"}

package/dist/kinds/plane.d.ts

@@ -0,0 +1,190 @@
+/**
+ * The `plane` kind (ADR 0038): points at coordinates and the segments
+ * between them, with named vertical lines (a sweep line, a dividing line)
+ * and optional axes, for computational geometry. Points and segments have
+ * ids, unique within the structure; a segment names its two end points.
+ *
+ * Marks: `highlight` and `compare` last one step; `visit`, `settle`,
+ * `select`, `pointer` and `line` persist.
+ */
+import { z } from 'zod';
+import { type DeclIssue, type KindSpec } from './kind.ts';
+/** Most points, segments and lines a plane holds. */
+export declare const MAX_POINTS = 64;
+export declare const MAX_SEGMENTS = 128;
+export declare const MAX_LINES = 8;
+/** A coordinate: a finite number from −10⁶ to 10⁶. */
+export declare const Coordinate: z.ZodNumber;
+export declare const PlanePoint: z.ZodObject<{
+    id: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PlanePoint = z.infer<typeof PlanePoint>;
+export declare const PlaneSegment: z.ZodObject<{
+    id: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PlaneSegment = z.infer<typeof PlaneSegment>;
+export declare const PlaneDecl: z.ZodObject<{
+    points: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    kind: z.ZodLiteral<"plane">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    axes: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type PlaneDecl = z.infer<typeof PlaneDecl>;
+export declare const PlaneDeclInput: z.ZodObject<{
+    points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    kind: z.ZodLiteral<"plane">;
+    label: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodEnum<{
+        main: "main";
+        side: "side";
+    }>>;
+    axes: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type PlaneDeclInput = z.infer<typeof PlaneDeclInput>;
+/** Points apart, segment ends known and distinct, one segment per pair. */
+export declare function validatePlaneDecl(decl: PlaneDecl): DeclIssue[];
+export declare const PlaneAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"addPoint">;
+    point: z.ZodObject<{
+        id: z.ZodString;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"removePoint">;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"addSegment">;
+    segment: z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"removeSegment">;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"label">;
+    segment: z.ZodString;
+    text: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    points: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"compare">;
+    points: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"visit">;
+    point: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    point: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"select">;
+    segment: z.ZodString;
+    on: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    name: z.ZodString;
+    point: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"line">;
+    name: z.ZodString;
+    x: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>], "type">;
+export type PlaneAction = z.infer<typeof PlaneAction>;
+export declare const PlaneActionInput: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"addPoint">;
+    point: z.ZodObject<{
+        id: z.ZodString;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"removePoint">;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"addSegment">;
+    segment: z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"removeSegment">;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"label">;
+    segment: z.ZodString;
+    text: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"highlight">;
+    points: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"compare">;
+    points: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"visit">;
+    point: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"settle">;
+    point: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"select">;
+    segment: z.ZodString;
+    on: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    name: z.ZodString;
+    point: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"line">;
+    name: z.ZodString;
+    x: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>], "type">;
+export type PlaneActionInput = PlaneAction;
+export declare const planeSpec: KindSpec<{
+    decl: PlaneDecl;
+    declInput: PlaneDeclInput;
+    action: PlaneAction;
+    actionInput: PlaneActionInput;
+}>;
+//# sourceMappingURL=plane.d.ts.map

package/dist/kinds/plane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plane.d.ts","sourceRoot":"","sources":["../../src/kinds/plane.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAW,KAAK,SAAS,EAAc,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE/E,qDAAqD;AACrD,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,sDAAsD;AACtD,eAAO,MAAM,UAAU,aAAgC,CAAC;AAIxD,eAAO,MAAM,UAAU;;;;;kBASU,CAAC;AAClC,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD,eAAO,MAAM,YAAY;;;;;kBAOmB,CAAC;AAC7C,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAYxD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;kBAMsD,CAAC;AAC7E,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;kBAUiD,CAAC;AAC7E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAK5D,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,EAAE,CAoC9D;AAsFD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAU,CAAC;AACnC,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACtD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAU,CAAC;AACxC,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC;AAE3C,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,cAAc,CAAC;IAC1B,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,gBAAgB,CAAC;CAC/B,CA0BA,CAAC"}