manim-web 0.27.0 → 0.28.0

package/dist/mobjects/ml/ConvolutionalLayer.d.ts

@@ -0,0 +1,19 @@
+import { NeuralNetworkLayer } from './NeuralNetworkLayer';
+import { NodeStyleOptions } from './mlStyles';
+export interface ConvolutionalLayerOptions {
+    /** Number of feature-map squares in the stack. Default: 3. Must be >= 0. */
+    numFeatureMaps?: number;
+    /** Side length of each square feature map. Default: 0.5. */
+    mapSize?: number;
+    /** Diagonal offset between adjacent squares. Default: 0.15. */
+    offset?: number;
+    /** Node style overrides for the squares. */
+    nodeStyle?: NodeStyleOptions;
+}
+export declare class ConvolutionalLayer extends NeuralNetworkLayer {
+    private readonly _width;
+    constructor(options?: ConvolutionalLayerOptions);
+    /** Horizontal extent of the feature-map stack, used for spacing. */
+    layerWidth(): number;
+}
+//# sourceMappingURL=ConvolutionalLayer.d.ts.map

package/dist/mobjects/ml/ConvolutionalLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvolutionalLayer.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/ConvolutionalLayer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EACL,gBAAgB,EAIjB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,yBAAyB;IACxC,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AAED,qBAAa,kBAAmB,SAAQ,kBAAkB;IACxD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,OAAO,GAAE,yBAA8B;IAgBnD,oEAAoE;IAC3D,UAAU,IAAI,MAAM;CAG9B"}

package/dist/mobjects/ml/EdgePulse.d.ts

@@ -0,0 +1,30 @@
+import { VMobject } from '../../core/VMobject';
+import { Animation, AnimationOptions } from '../../animation/Animation';
+export interface EdgePulseOptions extends AnimationOptions {
+    /** Color the line takes when fully active. Default: white. */
+    activationColor?: string;
+    /** Peak stroke opacity at full activation. Default: 1. */
+    peakOpacity?: number;
+    /** When true, the line fades back to its resting look at alpha 1. Default: false. */
+    restore?: boolean;
+}
+export declare class EdgePulse extends Animation {
+    /** The activation level set on the most recent interpolate call, 0 to 1. */
+    activation: number;
+    private readonly _activationColor;
+    private readonly _peakOpacity;
+    private readonly _restore;
+    private _baseOpacity;
+    private _baseColor;
+    constructor(line: VMobject, options?: EdgePulseOptions);
+    begin(): void;
+    interpolate(alpha: number): void;
+    finish(): void;
+}
+/**
+ * Create an EdgePulse animation for one connection line.
+ * @param line - The connection line to animate.
+ * @param options - Activation color, peak opacity, restore and timing options.
+ */
+export declare function edgePulse(line: VMobject, options?: EdgePulseOptions): EdgePulse;
+//# sourceMappingURL=EdgePulse.d.ts.map

package/dist/mobjects/ml/EdgePulse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdgePulse.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/EdgePulse.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAIxE,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACxD,8DAA8D;IAC9D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qFAAqF;IACrF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,SAAU,SAAQ,SAAS;IACtC,4EAA4E;IAC5E,UAAU,EAAE,MAAM,CAAK;IAEvB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IACnC,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,UAAU,CAAc;gBAEpB,IAAI,EAAE,QAAQ,EAAE,OAAO,GAAE,gBAAqB;IAWjD,KAAK,IAAI,IAAI;IAOtB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAYvB,MAAM,IAAI,IAAI;CAWxB;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAE/E"}

package/dist/mobjects/ml/FeedForwardLayer.d.ts

@@ -0,0 +1,31 @@
+import { NeuralNetworkLayer } from './NeuralNetworkLayer';
+import { NodeStyleOptions } from './mlStyles';
+export interface FeedForwardLayerOptions {
+    /** Number of nodes (circles) in the column. Default: 3. Must be >= 0. */
+    numNodes?: number;
+    /** Radius of each node circle. Default: 0.25. */
+    nodeRadius?: number;
+    /** Vertical gap between the centers of adjacent nodes. Default: 0.7. */
+    nodeSpacing?: number;
+    /** Node style overrides. */
+    nodeStyle?: NodeStyleOptions;
+}
+export declare class FeedForwardLayer extends NeuralNetworkLayer {
+    private readonly _nodeRadius;
+    private readonly _nodeSpacing;
+    private readonly _nodeStyle;
+    constructor(options?: FeedForwardLayerOptions);
+    /**
+     * Build `count` circles in a vertical column centered on the local origin.
+     * @param count - Number of circles to create (0 leaves the layer empty).
+     */
+    private _buildNodes;
+    /** Get the radius of each node circle. */
+    getNodeRadius(): number;
+    /**
+     * Horizontal extent of the column (one circle wide), used for spacing.
+     * Stays positive even with zero nodes so the network can place an empty layer.
+     */
+    layerWidth(): number;
+}
+//# sourceMappingURL=FeedForwardLayer.d.ts.map

package/dist/mobjects/ml/FeedForwardLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeedForwardLayer.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/FeedForwardLayer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,gBAAgB,EAIjB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,uBAAuB;IACtC,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4BAA4B;IAC5B,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AAED,qBAAa,gBAAiB,SAAQ,kBAAkB;IACtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;gBAEnC,OAAO,GAAE,uBAA4B;IAYjD;;;OAGG;IACH,OAAO,CAAC,WAAW;IAoBnB,0CAA0C;IAC1C,aAAa,IAAI,MAAM;IAIvB;;;OAGG;IACM,UAAU,IAAI,MAAM;CAG9B"}

package/dist/mobjects/ml/ImageLayer.d.ts

@@ -0,0 +1,29 @@
+import { NeuralNetworkLayer } from './NeuralNetworkLayer';
+import { NodeStyleOptions } from './mlStyles';
+export interface ImageLayerOptions {
+    /** Number of pixel rows. Default: 3. Must be >= 0. */
+    rows?: number;
+    /** Number of pixel columns. Default: 3. Must be >= 0. */
+    cols?: number;
+    /** Side length of each pixel cell. Default: 0.25. */
+    cellSize?: number;
+    /** Cell style overrides. */
+    nodeStyle?: NodeStyleOptions;
+}
+export declare class ImageLayer extends NeuralNetworkLayer {
+    private readonly _cols;
+    private readonly _cellSize;
+    private readonly _grid;
+    constructor(options?: ImageLayerOptions);
+    /**
+     * Build the pixel grid centered on the local origin.
+     * @param rows - Number of rows.
+     * @param cols - Number of columns.
+     * @param style - Resolved cell style.
+     * @returns A VGroup of cell rectangles (empty when rows or cols is 0).
+     */
+    private _buildGrid;
+    /** Horizontal extent of the grid, always positive for spacing. */
+    layerWidth(): number;
+}
+//# sourceMappingURL=ImageLayer.d.ts.map

package/dist/mobjects/ml/ImageLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageLayer.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/ImageLayer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,gBAAgB,EAIjB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,iBAAiB;IAChC,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AAED,qBAAa,UAAW,SAAQ,kBAAkB;IAChD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,OAAO,GAAE,iBAAsB;IAiB3C;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAwBlB,kEAAkE;IACzD,UAAU,IAAI,MAAM;CAG9B"}

package/dist/mobjects/ml/NeuralNetwork.d.ts

@@ -0,0 +1,69 @@
+import { VGroup } from '../../core/VGroup';
+import { Line } from '../geometry/Line';
+import { NeuralNetworkLayer } from './NeuralNetworkLayer';
+import { ConnectionStyleOptions } from './mlStyles';
+/**
+ * NeuralNetwork - a diagram of stacked layers with connection lines between
+ * adjacent layers (a manim-ml NeuralNetwork analogue).
+ *
+ * The network is a VGroup built from a list of layers. It places the layers
+ * left to right and, for every adjacent pair, draws a dense set of connection
+ * lines between their node anchors (n_i x n_{i+1} lines). Connections are added
+ * before the layers so they render behind the nodes.
+ */
+import * as THREE from 'three';
+export interface NeuralNetworkOptions {
+    /** Horizontal gap between adjacent layers. Default: 1. */
+    layerSpacing?: number;
+    /** Connection line style overrides. */
+    edgeStyle?: ConnectionStyleOptions;
+    /** When false, no connection lines are drawn. Default: true. */
+    connectAdjacent?: boolean;
+}
+export declare class NeuralNetwork extends VGroup {
+    private readonly _layers;
+    private readonly _connections;
+    /** Connection lines grouped by the gap they cross (stage i joins layer i and i+1). */
+    private readonly _stages;
+    private readonly _edgeStyle;
+    /**
+     * @param layers - The layers, drawn left to right in array order.
+     * @param options - Spacing, edge style and whether to connect layers.
+     */
+    constructor(layers?: NeuralNetworkLayer[], options?: NeuralNetworkOptions);
+    /**
+     * A container flattens its transform into its children (layers and lines)
+     * rather than baking its own geometry, matching GenericGraph.
+     */
+    normalizeTransform(worldMatrix?: THREE.Matrix4): this;
+    /**
+     * Place each layer so its center sits on a strictly increasing x, spaced by
+     * the layers' own widths plus `layerSpacing`. Uses shift (not moveTo) so an
+     * empty layer is positioned without measuring absent geometry.
+     * @param layerSpacing - Horizontal gap between adjacent layer edges.
+     */
+    private _placeLayers;
+    /**
+     * Build dense connection lines between every adjacent pair of layers.
+     * A pair contributes n_i x n_{i+1} lines; a 0-node layer contributes none.
+     */
+    private _buildConnections;
+    /** Get the layers in left-to-right order. */
+    getLayers(): NeuralNetworkLayer[];
+    /**
+     * Get a single layer by index.
+     * @param index - Zero-based layer index.
+     * @returns The layer, or undefined when the index is out of range.
+     */
+    getLayer(index: number): NeuralNetworkLayer | undefined;
+    /** Get the number of layers. */
+    get numLayers(): number;
+    /** Get every connection line, flattened across all gaps. */
+    getConnections(): Line[];
+    /**
+     * Get the connection lines grouped by gap. Entry i holds the lines that join
+     * layer i and layer i+1.
+     */
+    getConnectionStages(): Line[][];
+}
+//# sourceMappingURL=NeuralNetwork.d.ts.map

package/dist/mobjects/ml/NeuralNetwork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NeuralNetwork.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/NeuralNetwork.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,sBAAsB,EAIvB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,SAAS,CAAC,EAAE,sBAAsB,CAAC;IACnC,gEAAgE;IAChE,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,qBAAa,aAAc,SAAQ,MAAM;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAC3C,sFAAsF;IACtF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAE/C;;;OAGG;gBACS,MAAM,GAAE,kBAAkB,EAAO,EAAE,OAAO,GAAE,oBAAyB;IAkBjF;;;OAGG;IACM,kBAAkB,CAAC,WAAW,GAAE,KAAK,CAAC,OAA2B,GAAG,IAAI;IAIjF;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAapB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAsBzB,6CAA6C;IAC7C,SAAS,IAAI,kBAAkB,EAAE;IAIjC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAIvD,gCAAgC;IAChC,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,4DAA4D;IAC5D,cAAc,IAAI,IAAI,EAAE;IAIxB;;;OAGG;IACH,mBAAmB,IAAI,IAAI,EAAE,EAAE;CAGhC"}

package/dist/mobjects/ml/NeuralNetworkLayer.d.ts

@@ -0,0 +1,54 @@
+import { VGroup } from '../../core/VGroup';
+import { VMobject } from '../../core/VMobject';
+import { Vector3Tuple } from '../../core/Mobject';
+/**
+ * NeuralNetworkLayer - abstract base for every layer in a NeuralNetwork.
+ *
+ * A layer is a VGroup of node mobjects (circles, feature-map squares, a pixel
+ * grid). The NeuralNetwork places layers left to right and draws connection
+ * lines between the anchor points of adjacent layers. Each concrete layer
+ * exposes the same small interface so the network can treat them uniformly.
+ */
+import * as THREE from 'three';
+export declare abstract class NeuralNetworkLayer extends VGroup {
+    /**
+     * The node mobjects of this layer, in top-to-bottom order.
+     *
+     * A connection attaches to a node's center, so this list defines how many
+     * edges the network draws to the next layer. It may be empty (a layer with
+     * zero nodes), which the network treats as "no connections".
+     */
+    protected _nodes: VMobject[];
+    /**
+     * A container flattens its own transform into its children instead of baking
+     * geometry, exactly like GenericGraph. This keeps node centers and the
+     * connection lines (which the network positions in world space) correct when
+     * a scene normalizes the family.
+     */
+    normalizeTransform(worldMatrix?: THREE.Matrix4): this;
+    /**
+     * Get the node mobjects of this layer.
+     * @returns The nodes in top-to-bottom order (an empty array for a 0-node layer).
+     */
+    getNodes(): VMobject[];
+    /**
+     * Get the number of nodes (connection anchors) in this layer.
+     */
+    get numNodes(): number;
+    /**
+     * Get the world-space anchor point of each node, in node order.
+     *
+     * The network calls this after it has positioned the layer, so the centers
+     * already include the layer's placement offset.
+     * @returns One center per node (an empty array for a 0-node layer).
+     */
+    nodeAnchors(): Vector3Tuple[];
+    /**
+     * Get the horizontal extent used to space this layer from its neighbours.
+     *
+     * It must return a positive number even when the layer has zero nodes, so the
+     * network can lay out an empty layer without measuring absent geometry.
+     */
+    abstract layerWidth(): number;
+}
+//# sourceMappingURL=NeuralNetworkLayer.d.ts.map

package/dist/mobjects/ml/NeuralNetworkLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NeuralNetworkLayer.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/NeuralNetworkLayer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,8BAAsB,kBAAmB,SAAQ,MAAM;IACrD;;;;;;OAMG;IACH,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAM;IAElC;;;;;OAKG;IACM,kBAAkB,CAAC,WAAW,GAAE,KAAK,CAAC,OAA2B,GAAG,IAAI;IAIjF;;;OAGG;IACH,QAAQ,IAAI,QAAQ,EAAE;IAItB;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;;;;OAMG;IACH,WAAW,IAAI,YAAY,EAAE;IAI7B;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,IAAI,MAAM;CAC9B"}

package/dist/mobjects/ml/PoolingLayer.d.ts

@@ -0,0 +1,19 @@
+import { NeuralNetworkLayer } from './NeuralNetworkLayer';
+import { NodeStyleOptions } from './mlStyles';
+export interface PoolingLayerOptions {
+    /** Number of feature-map squares in the stack. Default: 3. Must be >= 0. */
+    numFeatureMaps?: number;
+    /** Side length of each square feature map. Default: 0.3. */
+    mapSize?: number;
+    /** Diagonal offset between adjacent squares. Default: 0.12. */
+    offset?: number;
+    /** Node style overrides for the squares. */
+    nodeStyle?: NodeStyleOptions;
+}
+export declare class PoolingLayer extends NeuralNetworkLayer {
+    private readonly _width;
+    constructor(options?: PoolingLayerOptions);
+    /** Horizontal extent of the feature-map stack, used for spacing. */
+    layerWidth(): number;
+}
+//# sourceMappingURL=PoolingLayer.d.ts.map

package/dist/mobjects/ml/PoolingLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PoolingLayer.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/PoolingLayer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EACL,gBAAgB,EAIjB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AAED,qBAAa,YAAa,SAAQ,kBAAkB;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,OAAO,GAAE,mBAAwB;IAgB7C,oEAAoE;IAC3D,UAAU,IAAI,MAAM;CAG9B"}

package/dist/mobjects/ml/featureMapStack.d.ts

@@ -0,0 +1,25 @@
+import { VMobject } from '../../core/VMobject';
+import { ResolvedNodeStyle } from './mlStyles';
+export interface FeatureMapStackConfig {
+    /** Number of stacked feature-map squares. Must be >= 0. */
+    numFeatureMaps: number;
+    /** Side length of each square feature map. */
+    mapSize: number;
+    /** Diagonal offset between adjacent squares in the stack. */
+    offset: number;
+    /** Resolved node style for the squares. */
+    style: ResolvedNodeStyle;
+}
+export interface FeatureMapStackResult {
+    /** The feature-map squares, front (first) to back (last). */
+    nodes: VMobject[];
+    /** Horizontal extent of the stack, always positive. */
+    width: number;
+}
+/**
+ * Build a diagonal stack of square feature maps centered on the local origin.
+ * @param config - Count, size, offset and style of the stack.
+ * @returns The square nodes and the stack's horizontal extent.
+ */
+export declare function buildFeatureMapStack(config: FeatureMapStackConfig): FeatureMapStackResult;
+//# sourceMappingURL=featureMapStack.d.ts.map

package/dist/mobjects/ml/featureMapStack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"featureMapStack.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/featureMapStack.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,MAAM,WAAW,qBAAqB;IACpC,2DAA2D;IAC3D,cAAc,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,KAAK,EAAE,iBAAiB,CAAC;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACpC,6DAA6D;IAC7D,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,qBAAqB,GAAG,qBAAqB,CAyBzF"}

package/dist/mobjects/ml/forwardPass.d.ts

@@ -0,0 +1,28 @@
+import { Animation } from '../../animation/Animation';
+import { NeuralNetwork } from './NeuralNetwork';
+import { EdgePulseOptions } from './EdgePulse';
+export interface ForwardPassOptions extends EdgePulseOptions {
+    /**
+     * Overlap between consecutive gaps. 1 is strictly sequential (one gap fully
+     * lit before the next starts), 0 is all gaps at once. Default: 1.
+     */
+    lagRatio?: number;
+    /** Duration of each gap's pulse in seconds. Default: 1. */
+    gapDuration?: number;
+}
+/**
+ * Animate a forward pass: light each gap's connections from input to output.
+ * @param network - The network to animate.
+ * @param options - Pulse color/opacity, lagRatio and per-gap duration.
+ * @returns A LaggedStart over the gaps (an empty, zero-duration one for a
+ *          network with fewer than two layers).
+ */
+export declare function forwardPass(network: NeuralNetwork, options?: ForwardPassOptions): Animation;
+/**
+ * Animate a backward pass: light each gap's connections from output to input.
+ * @param network - The network to animate.
+ * @param options - Pulse color/opacity, lagRatio and per-gap duration.
+ * @returns A LaggedStart over the gaps in reverse order.
+ */
+export declare function backwardPass(network: NeuralNetwork, options?: ForwardPassOptions): Animation;
+//# sourceMappingURL=forwardPass.d.ts.map

package/dist/mobjects/ml/forwardPass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwardPass.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/forwardPass.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAItD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAa,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE1D,MAAM,WAAW,kBAAmB,SAAQ,gBAAgB;IAC1D;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA8BD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,GAAE,kBAAuB,GAAG,SAAS,CAG/F;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,GAAE,kBAAuB,GAAG,SAAS,CAGhG"}

package/dist/mobjects/ml/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Neural-network / ML diagram toolkit for manim-web.
+ *
+ * A manim-ml analogue built purely by composition: layers are VGroups of
+ * geometry, the network arranges them and draws connections, and forward /
+ * backward passes animate a signal flowing through the connections.
+ */
+export { type NodeStyleOptions, type ConnectionStyleOptions, type ResolvedNodeStyle, type ResolvedEdgeStyle, DEFAULT_NODE_STYLE, DEFAULT_EDGE_STYLE, DEFAULT_ACTIVATION_COLOR, resolveNodeStyle, resolveEdgeStyle, } from './mlStyles';
+export { NeuralNetworkLayer } from './NeuralNetworkLayer';
+export { FeedForwardLayer, type FeedForwardLayerOptions } from './FeedForwardLayer';
+export { ConvolutionalLayer, type ConvolutionalLayerOptions } from './ConvolutionalLayer';
+export { PoolingLayer, type PoolingLayerOptions } from './PoolingLayer';
+export { ImageLayer, type ImageLayerOptions } from './ImageLayer';
+export { buildFeatureMapStack, type FeatureMapStackConfig, type FeatureMapStackResult, } from './featureMapStack';
+export { NeuralNetwork, type NeuralNetworkOptions } from './NeuralNetwork';
+export { EdgePulse, edgePulse, type EdgePulseOptions } from './EdgePulse';
+export { forwardPass, backwardPass, type ForwardPassOptions } from './forwardPass';
+//# sourceMappingURL=index.d.ts.map

package/dist/mobjects/ml/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AACpF,OAAO,EAAE,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGlE,OAAO,EACL,oBAAoB,EACpB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,GAC3B,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAG3E,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC"}

package/dist/mobjects/ml/mlStyles.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared style options and defaults for the neural-network diagram toolkit.
+ *
+ * These interfaces describe how nodes (circles, feature maps, grids) and the
+ * connection lines between layers look. Every field is optional; the layer and
+ * network classes fill the gaps from the DEFAULT_* records below.
+ */
+/** Visual style for a single node (a circle, a feature-map square, a grid). */
+export interface NodeStyleOptions {
+    /** Stroke color as a CSS color string. */
+    color?: string;
+    /** Fill color as a CSS color string. Defaults to `color`. */
+    fillColor?: string;
+    /** Fill opacity from 0 to 1. */
+    fillOpacity?: number;
+    /** Stroke width in pixels. */
+    strokeWidth?: number;
+}
+/** Visual style for a connection line (an edge) between two nodes. */
+export interface ConnectionStyleOptions {
+    /** Stroke color as a CSS color string. */
+    color?: string;
+    /** Stroke width in pixels. */
+    strokeWidth?: number;
+    /** Resting stroke opacity from 0 to 1, before a forward pass activates it. */
+    opacity?: number;
+}
+/** Fully resolved node style (no optional fields). */
+export type ResolvedNodeStyle = Required<NodeStyleOptions>;
+/** Fully resolved edge style (no optional fields). */
+export type ResolvedEdgeStyle = Required<ConnectionStyleOptions>;
+/** Default node style: a blue outline with a faint blue fill. */
+export declare const DEFAULT_NODE_STYLE: ResolvedNodeStyle;
+/** Default edge style: a thin grey line at a low resting opacity. */
+export declare const DEFAULT_EDGE_STYLE: ResolvedEdgeStyle;
+/** Default color a connection takes while a signal flows through it. */
+export declare const DEFAULT_ACTIVATION_COLOR = "#FFFFFF";
+/**
+ * Merge a partial node style over a resolved base style.
+ * @param base - The resolved style to start from.
+ * @param override - The partial style whose set fields win.
+ * @returns A new resolved node style.
+ */
+export declare function resolveNodeStyle(base: ResolvedNodeStyle, override?: NodeStyleOptions): ResolvedNodeStyle;
+/**
+ * Merge a partial edge style over a resolved base style.
+ * @param base - The resolved style to start from.
+ * @param override - The partial style whose set fields win.
+ * @returns A new resolved edge style.
+ */
+export declare function resolveEdgeStyle(base: ResolvedEdgeStyle, override?: ConnectionStyleOptions): ResolvedEdgeStyle;
+//# sourceMappingURL=mlStyles.d.ts.map

package/dist/mobjects/ml/mlStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mlStyles.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/mlStyles.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gCAAgC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8BAA8B;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,sEAAsE;AACtE,MAAM,WAAW,sBAAsB;IACrC,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,sDAAsD;AACtD,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAC;AAE3D,sDAAsD;AACtD,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,sBAAsB,CAAC,CAAC;AAEjE,iEAAiE;AACjE,eAAO,MAAM,kBAAkB,EAAE,iBAKhC,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,EAAE,iBAIhC,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,wBAAwB,YAAQ,CAAC;AAE9C;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,iBAAiB,EACvB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,iBAAiB,CAEnB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,iBAAiB,EACvB,QAAQ,CAAC,EAAE,sBAAsB,GAChC,iBAAiB,CAEnB"}

package/dist/mobjects/physics/PhysicsWorld.d.ts

@@ -0,0 +1,83 @@
+import { Group } from '../../core/Group';
+import { Body, BodyOptions } from './bodies';
+import { Constraint } from './constraints';
+import { Bounds } from './collisions';
+import { Vec2 } from './vec2';
+/** Options for a {@link PhysicsWorld}. */
+export interface PhysicsWorldOptions {
+    /** Global acceleration `[x, y]` in units/sec^2. Default: `[0, -9.8]`. */
+    gravity?: Vec2;
+    /** World bounds for wall collisions. Default: open on every side. */
+    bounds?: Bounds;
+    /** Constraint position-solver iterations per step. Default: 4. */
+    iterations?: number;
+    /** Seed for the deterministic PRNG. Default: 0. */
+    seed?: number;
+}
+/**
+ * A 2D rigid-body physics world. See the file overview for the model and an
+ * example.
+ */
+export declare class PhysicsWorld extends Group {
+    private readonly _bodies;
+    private readonly _constraints;
+    private _gravity;
+    private _bounds;
+    private readonly _iterations;
+    private _seed;
+    private _rng;
+    constructor(options?: PhysicsWorldOptions);
+    /** The seed that drives the deterministic PRNG. */
+    get seed(): number;
+    /** The current global gravity `[x, y]`. */
+    getGravity(): Vec2;
+    /** Set the global gravity `[x, y]`. */
+    setGravity(gravity: Vec2): this;
+    /** Set the world bounds for wall collisions. */
+    setBounds(bounds: Bounds): this;
+    /** The next deterministic random float in `[0, 1)`. */
+    random(): number;
+    /**
+     * Add a body to the world. Accepts a {@link Body} or plain options. If the
+     * body carries a mobject, it is added as a child so the scene renders it.
+     *
+     * @returns The body that was added, for building constraints.
+     */
+    addBody(bodyOrOptions: Body | BodyOptions): Body;
+    /** Add a constraint to the world. @returns The constraint, for chaining. */
+    addConstraint<T extends Constraint>(constraint: T): T;
+    /** All bodies, in insertion order. The array is a copy; the bodies are live. */
+    getBodies(): Body[];
+    /** The body at `index`, or undefined. */
+    getBody(index: number): Body | undefined;
+    /** All constraints, in insertion order. The array is a copy. */
+    getConstraints(): Constraint[];
+    /**
+     * Advance the simulation by `dt` seconds with semi-implicit Euler:
+     * accumulate forces, integrate velocity then position, solve constraint
+     * positions, resolve collisions, and move the attached mobjects.
+     *
+     * @param dt - Elapsed time in seconds. Values <= 0 are ignored.
+     */
+    step(dt: number): this;
+    /** Add gravity and spring forces to every body for this step. */
+    private _accumulateForces;
+    /** Semi-implicit Euler: velocity from force, then position from velocity. */
+    private _integrate;
+    /** Run the position solver for each constraint, several iterations. */
+    private _solveConstraints;
+    /** Resolve every body against the bounds and every circle pair. */
+    private _resolveCollisions;
+    /** Move each attached mobject to its body position, keeping its z. */
+    private _syncMobjects;
+    /**
+     * Restore every body to its initial state and restart the PRNG from the
+     * seed. After a reset, the same sequence of {@link step} calls reproduces
+     * the same evolution.
+     */
+    reset(): this;
+    copy(): PhysicsWorld;
+    /** Build a new body with the same state and a copied mobject. */
+    private _cloneBody;
+}
+//# sourceMappingURL=PhysicsWorld.d.ts.map

package/dist/mobjects/physics/PhysicsWorld.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsWorld.d.ts","sourceRoot":"","sources":["../../../src/mobjects/physics/PhysicsWorld.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAsC,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAiB9B,0CAA0C;AAC1C,MAAM,WAAW,mBAAmB;IAClC,yEAAyE;IACzE,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAO;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,IAAI,CAAe;gBAEf,OAAO,GAAE,mBAAwB;IAa7C,mDAAmD;IACnD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,2CAA2C;IAC3C,UAAU,IAAI,IAAI;IAIlB,uCAAuC;IACvC,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAK/B,gDAAgD;IAChD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK/B,uDAAuD;IACvD,MAAM,IAAI,MAAM;IAIhB;;;;;OAKG;IACH,OAAO,CAAC,aAAa,EAAE,IAAI,GAAG,WAAW,GAAG,IAAI;IAOhD,4EAA4E;IAC5E,aAAa,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC;IAKrD,gFAAgF;IAChF,SAAS,IAAI,IAAI,EAAE;IAInB,yCAAyC;IACzC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAIxC,gEAAgE;IAChE,cAAc,IAAI,UAAU,EAAE;IAI9B;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAUtB,iEAAiE;IACjE,OAAO,CAAC,iBAAiB;IAWzB,6EAA6E;IAC7E,OAAO,CAAC,UAAU;IAgBlB,uEAAuE;IACvE,OAAO,CAAC,iBAAiB;IAQzB,mEAAmE;IACnE,OAAO,CAAC,kBAAkB;IAW1B,sEAAsE;IACtE,OAAO,CAAC,aAAa;IAQrB;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAOJ,IAAI,IAAI,YAAY;IAmB7B,iEAAiE;IACjE,OAAO,CAAC,UAAU;CAoBnB"}

package/dist/mobjects/physics/bodies.d.ts

@@ -0,0 +1,91 @@
+import { Mobject } from '../../core/Mobject';
+import { Vec2 } from './vec2';
+/** A circle shape with a radius, centered on the body position. */
+export interface CircleShape {
+    kind: 'circle';
+    /** Radius in scene units. */
+    radius: number;
+}
+/** A convex polygon shape, as vertices relative to the body position. */
+export interface PolygonShape {
+    kind: 'polygon';
+    /** Vertices in local space, measured from the body position. */
+    vertices: Vec2[];
+}
+/** The collision shape of a {@link Body}. */
+export type BodyShape = CircleShape | PolygonShape;
+/** Options for {@link Body}. */
+export interface BodyOptions {
+    /** Start position `[x, y]`. Default: `[0, 0]`. */
+    position?: Vec2;
+    /** Start velocity `[x, y]` in units/sec. Default: `[0, 0]`. */
+    velocity?: Vec2;
+    /** Mass in arbitrary units. Ignored when `isStatic` is true. Default: 1. */
+    mass?: number;
+    /** Bounciness from 0 (no bounce) to 1 (elastic). Default: 0.5. */
+    restitution?: number;
+    /** A static body never moves and has infinite mass. Default: false. */
+    isStatic?: boolean;
+    /** Collision shape. Default: a circle of radius 0.5. */
+    shape?: BodyShape;
+    /**
+     * Scale on the world gravity for this body, so a body can ignore gravity
+     * (0) or feel more or less than the rest. Default: 1.
+     */
+    gravityScale?: number;
+    /** A mobject to move to the body position on each step. Default: none. */
+    mobject?: Mobject;
+}
+/**
+ * A rigid body in the physics world.
+ *
+ * The body is the single source of truth for its motion. An attached mobject
+ * follows the body, never the other way around.
+ *
+ * @example
+ * ```typescript
+ * const ball = new Body({
+ *   position: [0, 3],
+ *   shape: { kind: 'circle', radius: 0.2 },
+ *   restitution: 0.8,
+ * });
+ * ```
+ */
+export declare class Body {
+    /** Current position `[x, y]`. */
+    position: Vec2;
+    /** Current velocity `[x, y]` in units/sec. */
+    velocity: Vec2;
+    /** Force accumulator for the current step, cleared after integration. */
+    force: Vec2;
+    /** Mass in arbitrary units. A static body reports `Infinity`. */
+    readonly mass: number;
+    /** Inverse mass. Zero for a static body, which disables all motion. */
+    readonly invMass: number;
+    /** Bounciness from 0 to 1. */
+    readonly restitution: number;
+    /** Whether the body is static (never moves). */
+    readonly isStatic: boolean;
+    /** The collision shape. */
+    readonly shape: BodyShape;
+    /** Per-body scale on the world gravity. */
+    readonly gravityScale: number;
+    /** The attached mobject, or null. */
+    mobject: Mobject | null;
+    /** The z of the attached mobject at attach time, kept on every move. */
+    readonly z: number;
+    private readonly _initial;
+    constructor(options?: BodyOptions);
+    /** The circle radius, or 0 for a polygon body. */
+    get radius(): number;
+    /** Add a force `[x, y]` to the accumulator for the current step. */
+    applyForce(f: Vec2): this;
+    /**
+     * The axis-aligned bounds as `[minX, minY, maxX, maxY]` in world space.
+     * A circle uses its radius; a polygon uses its vertex extent.
+     */
+    aabb(): [number, number, number, number];
+    /** Restore the position and velocity recorded when the body was created. */
+    reset(): this;
+}
+//# sourceMappingURL=bodies.d.ts.map

package/dist/mobjects/physics/bodies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bodies.d.ts","sourceRoot":"","sources":["../../../src/mobjects/physics/bodies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAa,MAAM,QAAQ,CAAC;AAEzC,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,gEAAgE;IAChE,QAAQ,EAAE,IAAI,EAAE,CAAC;CAClB;AAED,6CAA6C;AAC7C,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,YAAY,CAAC;AAEnD,gCAAgC;AAChC,MAAM,WAAW,WAAW;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,wDAAwD;IACxD,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAQD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,IAAI;IACf,iCAAiC;IACjC,QAAQ,EAAE,IAAI,CAAC;IACf,8CAA8C;IAC9C,QAAQ,EAAE,IAAI,CAAC;IACf,yEAAyE;IACzE,KAAK,EAAE,IAAI,CAAU;IACrB,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8BAA8B;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,2BAA2B;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,2CAA2C;IAC3C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,qCAAqC;IACrC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAEnB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;gBAE5B,OAAO,GAAE,WAAgB;IA8BrC,kDAAkD;IAClD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,oEAAoE;IACpE,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAMzB;;;OAGG;IACH,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAyBxC,4EAA4E;IAC5E,KAAK,IAAI,IAAI;CAMd"}