melonjs 17.3.0 → 18.0.0

package/build/math/matrix3d.d.ts

@@ -0,0 +1,188 @@
+import { Point } from "../geometries/point.ts";
+import { Matrix2d } from "./matrix2d.ts";
+import { Vector2d } from "./vector2d.ts";
+import { Vector3d } from "./vector3d.ts";
+type SixteenNumbers = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+type ConstructorArg = [Matrix3d] | SixteenNumbers | [undefined] | [];
+/**
+ * a 4x4 Matrix3d Object
+ */
+export declare class Matrix3d {
+    /**
+     * The matrix values
+     */
+    val: Float32Array;
+    /**
+     * Constructs a new Matrix3d object.
+     * @param value - The values to initialize the matrix with.
+     */
+    constructor(...value: ConstructorArg);
+    /**
+     * Gets the tx component of the matrix.
+     * @returns The tx component of the matrix.
+     */
+    get tx(): number;
+    /**
+     * Gets the ty component of the matrix.
+     * @returns The ty component of the matrix.
+     */
+    get ty(): number;
+    /**
+     * Gets the tz component of the matrix.
+     * @returns The tz component of the matrix.
+     */
+    get tz(): number;
+    /**
+     * reset the transformation matrix to the identity matrix (no transformation).<br>
+     * the identity matrix and parameters position : <br>
+     * <img src="images/identity-matrix_2x.png"/>
+     * @returns Reference to this object for method chaining
+     */
+    identity(): this;
+    /**
+     * Set the matrix to the specified value.
+     * @param values - The matrix components.
+     * @returns Reference to this object for method chaining
+     */
+    setTransform(...values: SixteenNumbers): this;
+    /**
+     * Copies over the values from another me.Matrix3d.
+     * @param m - the matrix object to copy from
+     * @returns Reference to this object for method chaining
+     */
+    copy(m: Matrix3d): this;
+    /**
+     * Copies over the upper-left 2x2 values from the given me.Matrix2d
+     * @param m - the matrix object to copy from
+     * @returns Reference to this object for method chaining
+     */
+    fromMat2d(m: Matrix2d): this;
+    /**
+     * multiply both matrix
+     * @param m - Other matrix
+     * @returns Reference to this object for method chaining
+     */
+    multiply(m: Matrix3d): this;
+    /**
+     * Transpose the value of this matrix.
+     * @returns Reference to this object for method chaining
+     */
+    transpose(): this;
+    /**
+     * invert this matrix, causing it to apply the opposite transformation.
+     * @returns Reference to this object for method chaining
+     */
+    invert(): this;
+    /**
+     * apply the current transform to the given 2d or 3d vector or point
+     * @param v - the vector object to be transformed
+     * @returns result vector object.
+     */
+    apply(v: Vector3d | Vector2d | Point): Vector2d | Point | Vector3d;
+    /**
+     * apply the inverted current transform to the given 2d or 3d vector
+     * @param v - the vector object to be transformed
+     * @returns result vector object.
+     */
+    applyInverse(v: Vector3d | Vector2d): Vector2d | Vector3d;
+    /**
+     * generate an orthogonal projection matrix, with the result replacing the current matrix
+     * <img src="images/glOrtho.gif"/><br>
+     * @param left - farthest left on the x-axis
+     * @param right - farthest right on the x-axis
+     * @param bottom - farthest down on the y-axis
+     * @param top - farthest up on the y-axis
+     * @param near - distance to the near clipping plane along the -Z axis
+     * @param far - distance to the far clipping plane along the -Z axis
+     * @returns Reference to this object for method chaining
+     */
+    ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): this;
+    /**
+     * scale the matrix
+     * @param x - a number representing the abscissa of the scaling vector.
+     * @param [y] - a number representing the ordinate of the scaling vector.
+     * @param [z] - a number representing the depth vector
+     * @returns Reference to this object for method chaining
+     */
+    scale(x: number, y?: number, z?: number): this;
+    /**
+     * adds a 2D scaling transformation.
+     * @param v - scaling vector
+     * @returns Reference to this object for method chaining
+     */
+    scaleV(v: Vector3d): this;
+    /**
+     * specifies a 2D scale operation using the [sx, 1] scaling vector
+     * @param x - x scaling vector
+     * @returns Reference to this object for method chaining
+     */
+    scaleX(x: number): this;
+    /**
+     * specifies a 2D scale operation using the [1,sy] scaling vector
+     * @param y - y scaling vector
+     * @returns Reference to this object for method chaining
+     */
+    scaleY(y: number): this;
+    /**
+     * rotate this matrix (counter-clockwise) by the specified angle (in radians).
+     * @param angle - Rotation angle in radians.
+     * @param v - the axis to rotate around
+     * @returns Reference to this object for method chaining
+     */
+    rotate(angle: number, v: Vector3d): this | null;
+    /**
+     * translate the matrix position using the given vector
+     * @param x - a number representing the abscissa of the vector, or a vector object
+     * @param [y] - a number representing the ordinate of the vector.
+     * @param [z] - a number representing the depth of the vector
+     * @returns Reference to this object for method chaining
+     */
+    translate(x: number, y: number, z?: number): Matrix3d;
+    translate(vector: Vector3d | Vector2d): Matrix3d;
+    /**
+     * Check if the matrix is an identity matrix.
+     * @returns true if the matrix is an identity matrix
+     */
+    isIdentity(): boolean;
+    /**
+     * return true if the two matrices are identical
+     * @param m - the other matrix
+     * @returns true if both are equals
+     */
+    equals(m: Matrix3d): boolean;
+    /**
+     * Clone the Matrix
+     * @returns a cloned matrix
+     */
+    clone(): Matrix3d;
+    /**
+     * return an array representation of this Matrix
+     * @returns internal matrix values
+     */
+    toArray(): Float32Array<ArrayBufferLike>;
+    /**
+     * convert the object to a string representation
+     * @returns stringified representation
+     */
+    toString(): string;
+}
+export declare const matrix3dPool: import("../system/pool.ts").Pool<Matrix3d, ConstructorArg>;
+export {};
+//# sourceMappingURL=matrix3d.d.ts.map

package/build/math/matrix3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix3d.d.ts","sourceRoot":"","sources":["../../src/math/matrix3d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAG/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,KAAK,cAAc,GAAG;IACrB,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;CACN,CAAC;AAEF,KAAK,cAAc,GAAG,CAAC,QAAQ,CAAC,GAAG,cAAc,GAAG,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC;AAYrE;;GAEG;AACH,qBAAa,QAAQ;IACpB;;OAEG;IACH,GAAG,EAAE,YAAY,CAAC;IAElB;;;OAGG;gBACS,GAAG,KAAK,EAAE,cAAc;IAKpC;;;OAGG;IACH,IAAI,EAAE,WAEL;IAED;;;OAGG;IACH,IAAI,EAAE,WAEL;IAED;;;OAGG;IACH,IAAI,EAAE,WAEL;IAED;;;;;OAKG;IACH,QAAQ;IAIR;;;;OAIG;IACH,YAAY,CAAC,GAAG,MAAM,EAAE,cAAc;IAuBtC;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,QAAQ;IAKhB;;;;OAIG;IACH,SAAS,CAAC,CAAC,EAAE,QAAQ;IAsBrB;;;;OAIG;IACH,QAAQ,CAAC,CAAC,EAAE,QAAQ;IA+DpB;;;OAGG;IACH,SAAS;IAyBT;;;OAGG;IACH,MAAM;IAiEN;;;;OAIG;IACH,KAAK,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK;IAkBpC;;;;OAIG;IACH,YAAY,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ;IAWnC;;;;;;;;;;OAUG;IACH,KAAK,CACJ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM;IA2BZ;;;;;;OAMG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI;IAqB7B;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,QAAQ;IAIlB;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ;IA+DjC;;;;;;OAMG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ;IACrD,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ;IA6BhD;;;OAGG;IACH,UAAU;IAuBV;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,QAAQ;IAwBlB;;;OAGG;IACH,KAAK;IAIL;;;OAGG;IACH,OAAO;IAIP;;;OAGG;IACH,QAAQ;CASR;AAED,eAAO,MAAM,YAAY,4DAWxB,CAAC"}

package/build/math/observableVector2d.d.ts

@@ -0,0 +1,286 @@
+import { Vector2d } from "./vector2d.ts";
+/**
+ * Represents a point in a 3D coordinate vector that can be observed for changes.
+ */
+export declare class ObservableVector2d {
+    private _callback;
+    private _vector2d;
+    private _revoke;
+    private callBackEnabled;
+    /**
+     * Creates a new ObservableVector3d instance.
+     * @param x - The x-coordinate of the vector. Default is 0.
+     * @param y - The y-coordinate of the vector. Default is 0.
+     * @param callback - The callback function to be called when the point changes. Default is undefined.
+     */
+    constructor(x?: number, y?: number, callback?: () => void);
+    /**
+     * Sets the x and y coordinates of the point.
+     * @param x - The new x-coordinate value.
+     * @param y - The new y-coordinate value.
+     * @returns Reference to this object for method chaining.
+     */
+    set(x?: number, y?: number): this;
+    /**
+     * Sets the x and y coordinates of the point without triggering the callback.
+     * @param x - The new x-coordinate value.
+     * @param y - The new y-coordinate value.
+     * @returns Reference to this object for method chaining.
+     */
+    setMuted(x?: number, y?: number): this;
+    /**
+     * Gets the x-coordinate of the point.
+     */
+    get x(): number;
+    /**
+     * Sets the x-coordinate of the point.
+     * @param value - The new x-coordinate value.
+     */
+    set x(value: number);
+    /**
+     * Gets the y-coordinate of the point.
+     */
+    get y(): number;
+    /**
+     * Sets the y-coordinate of the point.
+     * @param value - The new y-coordinate value.
+     */
+    set y(value: number);
+    /**
+     * Sets the callback function to be called when the point changes.
+     * @param callback - The callback function.
+     */
+    setCallback(callback: () => void): void;
+    /**
+     * set the Vector x and y properties to 0
+     * @returns Reference to this object for method chaining
+     */
+    setZero(): this;
+    /**
+     * set the Vector x and y properties using the passed vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    setV(v: Vector2d | ObservableVector2d): this;
+    /**
+     * Add the passed vector to this vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    add(v: Vector2d | ObservableVector2d): this;
+    /**
+     * Substract the passed vector to this vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    sub(v: Vector2d | ObservableVector2d): this;
+    /**
+     * Multiply this vector values by the given scalar
+     * @param x x scale value
+     * @param [y] y scale value, if not passed, it uses the x value
+     * @returns Reference to this object for method chaining
+     */
+    scale(x: number, y?: number): this;
+    /**
+     * Convert this vector into isometric coordinate space
+     * @returns Reference to this object for method chaining
+     */
+    toIso(): this;
+    /**
+     * Convert this vector into 2d coordinate space
+     * @returns Reference to this object for method chaining
+     */
+    to2d(): this;
+    /**
+     * Multiply this vector values by the passed vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    scaleV(v: Vector2d | ObservableVector2d): this;
+    /**
+     * Divide this vector values by the passed value
+     * @param n - the value to divide the vector by
+     * @returns Reference to this object for method chaining
+     */
+    div(n: number): this;
+    /**
+     * Update this vector values to absolute values
+     * @returns Reference to this object for method chaining
+     */
+    abs(): this;
+    /**
+     * Clamp the vector value within the specified value range
+     * @param low minimum component value
+     * @param high maximum component value
+     * @returns new me.Vector2d
+     */
+    clamp(low: number, high: number): Vector2d;
+    /**
+     * Clamp this vector value within the specified value range
+     * @param low minimum component value
+     * @param high maximum component value
+     * @returns Reference to this object for method chaining
+     */
+    clampSelf(low: number, high: number): Vector2d;
+    /**
+     * Update this vector with the minimum value between this and the passed vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    minV(v: Vector2d | ObservableVector2d): this;
+    /**
+     * Update this vector with the maximum value between this and the passed vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    maxV(v: Vector2d | ObservableVector2d): this;
+    /**
+     * Floor the vector values
+     * @returns new Vector2d
+     */
+    floor(): Vector2d;
+    /**
+     * Floor this vector values
+     * @returns Reference to this object for method chaining
+     */
+    floorSelf(): Vector2d;
+    /**
+     * Ceil the vector values
+     * @returns new Vector2d
+     */
+    ceil(): Vector2d;
+    /**
+     * Ceil this vector values
+     * @returns Reference to this object for method chaining
+     */
+    ceilSelf(): Vector2d;
+    /**
+     * Negate the vector values
+     * @returns new Vector2d
+     */
+    negate(): Vector2d;
+    /**
+     * Negate this vector values
+     * @returns Reference to this object for method chaining
+     */
+    negateSelf(): Vector2d;
+    /**
+     * Copy the x,y values of the passed vector to this one
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    copy(v: Vector2d | ObservableVector2d): this;
+    /**
+     * Checks if this vector is equal to another vector or a pair of coordinates.
+     * @param args - Either two numbers representing x and y coordinates or a single Vector2d object.
+     * @returns True if the coordinates are equal, false otherwise.
+     * @example
+     * let v1 = new Vector2d(3, 4);
+     * let v2 = new Vector2d(3, 4);
+     * v1.equals(v2); // returns true
+     * @example
+     * let v = new Vector2d(3, 4);
+     * v.equals(3, 4); // returns true
+     */
+    equals(...args: [number, number] | [Vector2d] | [ObservableVector2d]): boolean;
+    /**
+     * normalize this vector (scale the vector so that its magnitude is 1)
+     * @returns Reference to this object for method chaining
+     */
+    normalize(): this;
+    /**
+     * change this vector to be perpendicular to what it was before.<br>
+     * (Effectively rotates it 90 degrees in a clockwise direction)
+     * @returns Reference to this object for method chaining
+     */
+    perp(): this;
+    /**
+     * Rotate this vector (counter-clockwise) by the specified angle (in radians).
+     * @param angle - The angle to rotate (in radians)
+     * @param [v] - an optional point to rotate around
+     * @returns Reference to this object for method chaining
+     */
+    rotate(angle: number, v?: Vector2d | ObservableVector2d): this;
+    /**
+     * return the dot product of this vector and the passed one
+     * @param v other vector
+     * @returns The dot product.
+     */
+    dot(v: Vector2d | ObservableVector2d): number;
+    /**
+     * return the cross product of this vector and the passed one
+     * @param v other vector
+     * @returns The cross product.
+     */
+    cross(v: Vector2d | ObservableVector2d): number;
+    /**
+     * return the square length of this vector
+     * @returns The length^2 of this vector.
+     */
+    length2(): number;
+    /**
+     * return the length (magnitude) of this vector
+     * @returns the length of this vector
+     */
+    length(): number;
+    /**
+     * Linearly interpolate between this vector and the given one.
+     * @param v other vector
+     * @param alpha - distance along the line (alpha = 0 will be this vector, and alpha = 1 will be the given one).
+     * @returns Reference to this object for method chaining
+     */
+    lerp(v: Vector2d | ObservableVector2d, alpha: number): this;
+    /**
+     * interpolate the position of this vector towards the given one by the given maximum step.
+     * @param target vector to rotate towards
+     * @param step - the maximum step per iteration (Negative values will push the vector away from the target)
+     * @returns Reference to this object for method chaining
+     */
+    moveTowards(target: Vector2d | ObservableVector2d, step: number): Vector2d | ObservableVector2d;
+    /**
+     * Calculates the Euclidean distance between this vector and another vector.
+     * @param v - The vector to which the distance is calculated.
+     * @returns The Euclidean distance between this vector and the given vector.
+     * @example
+     * let v1 = new Vector2d(3, 4);
+     * let v2 = new Vector2d(6, 8);
+     * v1.distance(v2); // returns 5
+     */
+    distance(v: Vector2d | ObservableVector2d): number;
+    /**
+     * return the angle between this vector and the passed one
+     * @param v other vector
+     * @returns angle in radians
+     */
+    angle(v: Vector2d | ObservableVector2d): number;
+    /**
+     * project this vector on to another vector.
+     * @param v - The vector to project onto.
+     * @returns Reference to this object for method chaining
+     */
+    project(v: Vector2d | ObservableVector2d): this;
+    /**
+     * Project this vector onto a vector of unit length.<br>
+     * This is slightly more efficient than `project` when dealing with unit vectors.
+     * @param v - The unit vector to project onto.
+     * @returns Reference to this object for method chaining
+     */
+    projectN(v: Vector2d | ObservableVector2d): this;
+    /**
+     * return a clone copy of this vector
+     * @param [cb] callback function to override the clone values
+     * @returns new Vector2d
+     */
+    clone(cb?: () => void): ObservableVector2d;
+    /**
+     * convert the object to a string representation
+     * @returns stringified representation of this vector
+     */
+    toString(): `x:${number},y:${number}`;
+    /**
+     * Revokes the proxy object, preventing further access to the ObservablePoint instance.
+     */
+    revoke(): void;
+}
+export declare const observableVector2dPool: import("../system/pool.ts").Pool<ObservableVector2d, [x?: number | undefined, y?: number | undefined, callback?: () => void]>;
+//# sourceMappingURL=observableVector2d.d.ts.map

package/build/math/observableVector2d.d.ts.map

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

package/build/math/observableVector2d_old.d.ts

@@ -0,0 +1,76 @@
+import { Vector2d } from "./vector2d";
+/**
+ * Function type for the observable vector update callback.
+ * @param options - The update options.
+ * @param options.newX - The new x value.
+ * @param options.newY - The new y value.
+ * @param options.currentX - The current x value.
+ * @param options.currentY - The current y value.
+ * @returns - The updated values or undefined. If the values are returned, they will become the new x and y values.
+ */
+export type ObservableVector2dUpdateFn = (options: {
+    newX: number;
+    newY: number;
+    currentX: number;
+    currentY: number;
+}) => {
+    x?: number | undefined;
+    y?: number | undefined;
+} | void;
+export interface ObservableVector2d extends Vector2d {
+    /**
+     * Returns a `Vector2d` copy of this `ObservableVector2d` object.
+     * @returns - The new Vector2d.
+     */
+    toVector2d(): Vector2d;
+    /**
+     * Sets the vector value without triggering the callback.
+     * @param x - The x value of the vector.
+     * @param y - The y value of the vector.
+     * @returns - Reference to this object for method chaining.
+     */
+    setMuted(x: number, y: number): ObservableVector2d;
+    /**
+     * Returns a clone copy of this vector.
+     * @returns - The cloned vector.
+     */
+    clone(): ObservableVector2d;
+    /**
+     * Negates the vector values.
+     * @returns - The negated vector.
+     */
+    negate(): ObservableVector2d;
+    /**
+     * Ceils the vector values.
+     * @returns - The ceiled vector.
+     */
+    ceil(): ObservableVector2d;
+    /**
+     * Floors the vector values.
+     * @returns - The floored vector.
+     */
+    floor(): ObservableVector2d;
+    /**
+     * Clamps the vector values within the specified value range.
+     * @param low - The lower bound.
+     * @param high - The upper bound.
+     * @returns - The clamped vector.
+     */
+    clamp(low: number, high: number): ObservableVector2d;
+}
+interface CreateObservableVector2dOptions {
+    target: Vector2d;
+    updateFn: ObservableVector2dUpdateFn;
+}
+/**
+ * Creates an observable vector.
+ * This function wraps a given `Vector2d` object with a proxy that intercepts changes to the `x` and `y` properties,
+ * allowing for custom update logic via the provided `updateFn` callback.
+ * @param options - The options for creating the observable vector.
+ * @param options.target - The target vector to be made observable.
+ * @param options.updateFn - The update function to be called whenever the vector's properties change.
+ * @returns - The observable vector with additional methods for vector manipulation.
+ */
+export declare const createObservableVector2d: (options: CreateObservableVector2dOptions) => ObservableVector2d;
+export {};
+//# sourceMappingURL=observableVector2d_old.d.ts.map

package/build/math/observableVector2d_old.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observableVector2d_old.d.ts","sourceRoot":"","sources":["../../src/math/observableVector2d_old.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAgB,MAAM,YAAY,CAAC;AAepD;;;;;;;;GAQG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,EAAE;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CACjB,KAAK;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GAAG,IAAI,CAAC;AAEhE,MAAM,WAAW,kBAAmB,SAAQ,QAAQ;IACnD;;;OAGG;IACH,UAAU,IAAI,QAAQ,CAAC;IAEvB;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAAC;IAEnD;;;OAGG;IACH,KAAK,IAAI,kBAAkB,CAAC;IAE5B;;;OAGG;IACH,MAAM,IAAI,kBAAkB,CAAC;IAE7B;;;OAGG;IACH,IAAI,IAAI,kBAAkB,CAAC;IAE3B;;;OAGG;IACH,KAAK,IAAI,kBAAkB,CAAC;IAE5B;;;;;OAKG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAAC;CACrD;AAED,UAAU,+BAA+B;IACxC,MAAM,EAAE,QAAQ,CAAC;IACjB,QAAQ,EAAE,0BAA0B,CAAC;CACrC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,GACpC,SAAS,+BAA+B,KAoFlC,kBACN,CAAC"}