@futdevpro/fsm-dynamo 1.14.10 → 1.14.12

package/src/_collections/utils/math/trigonometry.util.ts

@@ -11,6 +11,12 @@ export class DyFM_Trigonometry {
    * @param c átfogó
    * @param angle a befogó oldallal szemközti szög (fokban)
    * @returns befogó
+   * 
+   * @example
+   * ```ts
+   * const clamp = DyFM_Trigonometry.getClamp(10, 30);
+   * console.log(clamp); // 5
+   * ```
    */
   static getClamp(c: number, angle?: number): number {
     angle = angle !== undefined ? angle : 45;
@@ -24,6 +30,12 @@ export class DyFM_Trigonometry {
    * @param a befogó
    * @param c átfogó
    * @returns befogó
+   * 
+   * @example
+   * ```ts
+   * const clamp = DyFM_Trigonometry.getClampByClampAndHypotenuse(6, 10);
+   * console.log(clamp); // 8
+   * ```
    */
   static getClampByClampAndHypotenuse(a: number, c: number): number {
     if (a > c) {
@@ -45,6 +57,12 @@ export class DyFM_Trigonometry {
    * @param a egyik befogó
    * @param b másik befogó
    * @returns átfogó
+   * 
+   * @example
+   * ```ts
+   * const hypotenuse = DyFM_Trigonometry.getHypotenuse(3, 4);
+   * console.log(hypotenuse); // 5
+   * ```
    */
   static getHypotenuse(a: number, b?: number): number {
     b = b !== undefined ? b : a;
@@ -56,6 +74,12 @@ export class DyFM_Trigonometry {
    * Szög fokmértéket átalakítja radiánsra
    * @param angle szög fok
    * @returns szög radiáns
+   * 
+   * @example
+   * ```ts
+   * const radians = DyFM_Trigonometry.angleToRadians(180);
+   * console.log(radians); // 3.141592653589793
+   * ```
    */
   static angleToRadians(angle: number): number {
     return angle * Math.PI / 180;
@@ -65,6 +89,12 @@ export class DyFM_Trigonometry {
    * Szög radiáns mértéket átalakítja fokra
    * @param radians szög radiáns
    * @returns szög fok
+   * 
+   * @example
+   * ```ts
+   * const angle = DyFM_Trigonometry.radiansToAngle(3.141592653589793);
+   * console.log(angle); // 180
+   * ```
    */
   static radiansToAngle(radians: number): number {
     return radians / Math.PI * 180;

package/src/_collections/utils/math/vector2.util.ts

@@ -12,6 +12,13 @@ export type DyFM_Vector2_U = DyFM_Vector2_Util;
  * is that static functions return new Vector2, 
  * while instance functions change the current Vector2 and returns itself.
  * (if this is not true, report it as a bug)
+ * 
+ * @example
+ * ```ts
+ * const vector2 = new DyFM_Vector2_Util(1);
+ * const vector2 = new DyFM_Vector2_Util(1, 2);
+ * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+ * ```
  */
 export class DyFM_Vector2_Util implements DyFM_Vector2 {
   readonly isVector2Util: boolean = true;
@@ -102,6 +109,12 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   
   /**
    * returns the distance between two vectors
+   * 
+   * @example
+   * ```ts
+   * const distance = DyFM_Vector2_Util.distance({ x: 1, y: 2 }, { x: 3, y: 4 });
+   * console.log(distance); // 2.8284271247461903
+   * ```
    */
   static distance(a: DyFM_Vector2, b: DyFM_Vector2): number {
     return this.minus(a, b).magintude;
@@ -111,7 +124,13 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   }
 
   /**
-   * returns a new vector with the negative values of the original vector
+   * returns a new vector with the subtraction of two vectors
+   * 
+   * @example
+   * ```ts
+   * const minus = DyFM_Vector2_Util.minus({ x: 1, y: 2 }, { x: 3, y: 4 });
+   * console.log(minus); // { x: -2, y: -2 }
+   * ```
    */
   static minus(a: DyFM_Vector2, minusB: DyFM_Vector2): DyFM_Vector2_Util {
     return this.plus(a, this.negative(minusB));
@@ -124,6 +143,12 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
   /**
    * returns a new vector with the sum of two vectors
+   * 
+   * @example
+   * ```ts
+   * const plus = DyFM_Vector2_Util.plus({ x: 1, y: 2 }, { x: 3, y: 4 });
+   * console.log(plus); // { x: 4, y: 6 }
+   * ```
    */
   static plus(a: DyFM_Vector2, plusB: DyFM_Vector2): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(a.x + plusB.x, a.y + plusB.y);
@@ -136,7 +161,13 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   static readonly add = this.plus;
   readonly add = this.plus;
 
-  /** returns new multiplied Vector2 */
+  /** returns a new vector with the multiplication of two vectors
+   * @example
+   * ```ts
+   * const multiply = DyFM_Vector2_Util.multiply({ x: 1, y: 2 }, 2);
+   * console.log(multiply); // { x: 2, y: 4 }
+   * ```
+   */
   static multiply(v: DyFM_Vector2, n: number): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(v.x * n, v.y * n);
   }
@@ -144,7 +175,13 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
     return this.newValues(DyFM_Vector2_Util.multiply(this, n));
   }
 
-  /** returns new divided Vector2 */
+  /** returns a new vector with the division of two vectors
+   * @example
+   * ```ts
+   * const divide = DyFM_Vector2_Util.divide({ x: 1, y: 2 }, 2);
+   * console.log(divide); // { x: 0.5, y: 1 }
+   * ```
+   */
   static divide(v: DyFM_Vector2, divideBy: number): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(v.x / divideBy, v.y / divideBy);
   }
@@ -154,6 +191,13 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
     return this;
   }
 
+  /** returns the negative value of the original vector at new vector
+   * @example
+   * ```ts
+   * const negative = DyFM_Vector2_Util.negative({ x: 1, y: 2 });
+   * console.log(negative); // { x: -1, y: -2 }
+   * ```
+   */
   static negative(v: DyFM_Vector2): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(-v.x, -v.y);
   }
@@ -168,7 +212,13 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   }
 
   /**
-   * returns a new vector with the sum of a vector and the difference of two vectors
+   * returns a new vector with the rebase of the original vector
+   * 
+   * @example
+   * ```ts
+   * const rebase = DyFM_Vector2_Util.rebase({ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 });
+   * console.log(rebase); // { x: 4, y: 6 }
+   * ```
    */
   static rebase(v: DyFM_Vector2, baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): DyFM_Vector2_Util {
     return this.plus(v, this.minus(baseTo, baseFrom));
@@ -180,15 +230,28 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   }
 
   /**
-   * returns a new vector with the sum of a vector and the difference of two vectors
+   * returns a new vector with the rotation of the original vector by degrees
+   * 
+   * @example
+   * ```ts
+   * const rotate = DyFM_Vector2_Util.rotate({ x: 1, y: 2 }, 30);
+   * console.log(rotate); // { x: 0.8660254037844386, y: 1.5 }
+   * ```
    */
   static rotate(vector: DyFM_Vector2, angle: number): DyFM_Vector2_Util {
     const rad = DyFM_Trigonometry.angleToRadians(angle);
 
     return this.rotateRad(vector, rad);
   }
+
   /**
-   * returns a new vector with the sum of a vector and the difference of two vectors
+   * returns a new vector with the rotation of the original vector by radians
+   * 
+   * @example
+   * ```ts
+   * const rotateRad = DyFM_Vector2_Util.rotateRad({ x: 1, y: 2 }, 3.141592653589793);
+   * console.log(rotateRad); // { x: -1, y: 2 }
+   * ```
    */
   static rotateRad(vector: DyFM_Vector2, rad: number): DyFM_Vector2_Util {
     const cos = Math.cos(rad);
@@ -198,16 +261,30 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
     return new DyFM_Vector2_Util(newX, newY);
   }
+
   /**
-   * returns a new vector with the sum of a vector and the difference of two vectors
+   * returns a new vector with the rotation of the original vector by degrees
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * vector.rotate(30);
+   * ```
    */
   rotate(angle: number): this {
     this.newValues(DyFM_Vector2_Util.rotate(this, angle));
 
     return this;
   }
+
   /**
-   * returns a new vector with the sum of a vector and the difference of two vectors
+   * returns a new vector with the rotation of the original vector by radians
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * vector.rotateRad(3.141592653589793);
+   * ```
    */
   rotateRad(rad: number): this {
     this.newValues(DyFM_Vector2_Util.rotateRad(this, rad));
@@ -216,15 +293,28 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   }
 
   /**
-   * returns a new vector with the sum of a vector and the difference of two vectors
+   * returns a new DyFM_Vector2_Util with the new values
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * vector.newValues({ x: 3, y: 4 });
+   * ```
    */
   newValues(newV: DyFM_Vector2): this {
     this.newXY(newV.x, newV.y);
 
     return this;
   }
+
   /**
    * returns a new vector with the sum of a vector and the difference of two vectors
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * vector.newXY(3, 4);
+   * ```
    */
   newXY(newX: number, newY: number): this {
     this._x = newX;
@@ -234,8 +324,15 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
     return this;
   }
+
   /**
-   * returns a new vector with the sum of a vector and the difference of two vectors
+   * returns a new DyFM_Vector2_Util with the new values
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * DyFM_Vector2_Util.newValues(vector, { x: 3, y: 4 });
+   * ```
    */
   static newValues(to: DyFM_Vector2, newV: DyFM_Vector2): DyFM_Vector2 {
     to.x = newV.x;
@@ -248,36 +345,75 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   //// AI-ed UNCHECKED
   /**
    * returns the angle between two vectors
+   * 
+   * @example
+   * ```ts
+   * const angle = DyFM_Vector2_Util.angle({ x: 1, y: 2 }, { x: 3, y: 4 });
+   * console.log(angle); // 45
+   * ```
    */
   static angle(from: DyFM_Vector2, to: DyFM_Vector2): number {
     return DyFM_Trigonometry.radiansToAngle(DyFM_Vector2_Util.angleRad(from, to));
   }
+
   /**
    * returns the angle between two vectors in radians
+   * 
+   * @example
+   * ```ts
+   * const angleRad = DyFM_Vector2_Util.angleRad({ x: 1, y: 2 }, { x: 3, y: 4 });
+   * console.log(angleRad); // 0.7853981633974483
+   * ```
    */
   static angleRad(from: DyFM_Vector2, to: DyFM_Vector2): number {
     return Math.atan2(to.y - from.y, to.x - from.x);
   }
+
   /**
    * returns the angle between two vectors
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const angle = vector.angle({ x: 3, y: 4 });
+   * console.log(angle); // 45
+   * ```
    */
   angle(from: DyFM_Vector2, to: DyFM_Vector2): number {
     return DyFM_Vector2_Util.angle(from, to);
   }
   /**
    * returns the angle between two vectors in degrees
+   * 
+   * @example
+   * ```ts
+   * const angle = DyFM_Vector2_Util.deg({ x: 1, y: 2 });
+   * console.log(angle); // 45
    */
   static deg(vector: DyFM_Vector2): number {
     return DyFM_Trigonometry.radiansToAngle(DyFM_Vector2_Util.rad(vector));
   }
   /**
    * returns the angle between two vectors in radians
+   * 
+   * @example
+   * ```ts
+   * const angleRad = DyFM_Vector2_Util.rad({ x: 1, y: 2 });
+   * console.log(angleRad); // 0.7853981633974483
+   * ```
    */
   static rad(vector: DyFM_Vector2): number {
     return Math.atan2(vector.y, vector.x);
   }
   /**
-   * returns the angle between two vectors in degrees
+   * returns the vector angle in degrees
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const deg = vector.deg();
+   * console.log(deg); // 45
+   * ```
    */
   deg(): number {
     return DyFM_Vector2_Util.deg(this);
@@ -285,12 +421,25 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
   /**
    * returns math floor of the vector
+   * 
+   * @example
+   * ```ts
+   * const vector = DyFM_Vector2_Util.floor({ x: 1.5, y: 2.5 });
+   * console.log(vector); // { x: 1, y: 2 }
+   * ```
    */
   static floor(v: DyFM_Vector2): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(Math.floor(v.x), Math.floor(v.y));
   }
   /**
    * returns math floor of the vector
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1.5, y: 2.5 });
+   * const floor = vector.floor();
+   * console.log(floor); // { x: 1, y: 2 }
+   * ```
    */
   floor(): DyFM_Vector2_Util {
     return DyFM_Vector2_Util.floor(this);
@@ -299,12 +448,25 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
   /**
    * returns the direction vector from one point to another
+   * 
+   * @example
+   * ```ts
+   * const direction = DyFM_Vector2_Util.direction({ x: 1, y: 2 }, { x: 3, y: 4 });
+   * console.log(direction); // { x: 2, y: 2 }
+   * ```
    */
   static direction(from: DyFM_Vector2, to: DyFM_Vector2): DyFM_Vector2_Util {
     return DyFM_Vector2_Util.minus(to, from);
   }
   /**
    * returns the direction vector from one point to another
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const direction = vector.direction({ x: 3, y: 4 });
+   * console.log(direction); // { x: 2, y: 2 }
+   * ```
    */
   direction(to: DyFM_Vector2): DyFM_Vector2_Util {
     return DyFM_Vector2_Util.direction(this, to);
@@ -312,6 +474,12 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
   /**
    * returns a normalized vector
+   * 
+   * @example
+   * ```ts
+   * const vector = DyFM_Vector2_Util.normalize({ x: 1, y: 2 });
+   * console.log(vector); // { x: 0.4472135954999579, y: 0.8944271909999159 }
+   * ```
    */
   static normalize(v: DyFM_Vector2): DyFM_Vector2_Util {
     const v_U = new DyFM_Vector2_Util(v);
@@ -320,6 +488,13 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   }
   /**
    * returns a normalized vector
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * vector.normalize();
+   * console.log(vector); // { x: 0.4472135954999579, y: 0.8944271909999159 }
+   * ```
    */
   normalize(): void {
     this.newValues(DyFM_Vector2_Util.normalize(this));
@@ -327,13 +502,27 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   /** 
    * this will return a new instance, 
    * if you want to change the current instance, use normalize()
-  */
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const normalized = vector.normalized();
+   * console.log(normalized); // { x: 0.4472135954999579, y: 0.8944271909999159 }
+   * ```
+   */
   normalized(): DyFM_Vector2_Util {
     return DyFM_Vector2_Util.normalize(this);
   }
 
   /**
    * returns the magnitude of the vector
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const magnitude = vector.magnitude();
+   * console.log(magnitude); // 2.23606797749979
+   * ```
    */
   private calcMagnitude(): void {
     this._magintude = DyFM_Trigonometry.getHypotenuse(this._x, this._y);
@@ -341,6 +530,13 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
   /**
    * returns a new vector with the same values
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const clone = vector.clone();
+   * console.log(clone); // { x: 1, y: 2 }
+   * ```
    */
   clone(): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(this._x, this._y);
@@ -348,6 +544,14 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
   /**
    * returns true if the vector has changed
+   * 
+   * @example
+   * ```ts
+   * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const vector2 = new DyFM_Vector2_Util({ x: 3, y: 4 });
+   * const isChanged = DyFM_Vector2_Util.isChanged(vector1, vector2);
+   * console.log(isChanged); // true
+   * ```
    */
   static isChanged(a: DyFM_Vector2_Util, b: DyFM_Vector2_Util): boolean {
     return a.x !== b.x || a.y !== b.y;
@@ -355,27 +559,43 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
   /**
    * returns true if the vectors are equal
+   * 
+   * @example
+   * ```ts
+   * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const isEqual = DyFM_Vector2_Util.isEqual(vector1, vector2);
+   * console.log(isEqual); // true
+   * ```
    */
   static isEqual(a: DyFM_Vector2, b: DyFM_Vector2): boolean {
     return a.x === b.x && a.y === b.y;
   }
 
   /**
-   * returns true if the vectors are equal
+   * returns true if the vectors have changed
+   * 
+   * @example
+   * ```ts
+   * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const isVectorChanged = DyFM_Vector2_Util.vectorChanged(vector1, vector2);
+   * console.log(isVectorChanged); // false
+   * ```
    */
   static vectorChanged(a: DyFM_Vector2, b: DyFM_Vector2): boolean {
     return a.x !== b.x || a.y !== b.y;
   }
 
-  /**
-   * returns true if the vectors are equal
-   */
-  static equals(a: DyFM_Vector2, b: DyFM_Vector2): boolean {
-    return a.x === b.x && a.y === b.y;
-  }
-
   /**
    * returns a new vector with the absolute values of the original vector
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const vector = DyFM_Vector2_Util.abs(vector);
+   * console.log(vector);
+   * ```
    */
   static abs(v: DyFM_Vector2): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(Math.abs(v.x), Math.abs(v.y));
@@ -386,6 +606,13 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
   /**
    * returns a new vector with the rounded values of the original vector
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1.5, y: 2.5 });
+   * const rounded = DyFM_Vector2_Util.round(vector);
+   * const rounded2 = DyFM_Vector2_Util.round(vector,3);
+   * ```
    */
   static round(v: DyFM_Vector2, decimals: number = 0): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(
@@ -396,6 +623,13 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
   /**
    * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
+   * 
+   * @example
+   * ```ts
+   * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+   * const vector2 = DyFM_Vector2_Util.toVector2(vector);
+   * console.log(vector2);
+   * ```
    */
   static toVector2(v: DyFM_Vector2_Util): DyFM_Vector2 {
     return (new DyFM_Vector2_Util(v)).get();
@@ -417,7 +651,3 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
     return { x: v.x, y: v.y };
   }
 }
-
-
-
-

package/src/_collections/utils/regex/password-regex.util.ts

@@ -11,6 +11,18 @@ export const DyFM_passwordRegex: RegExp = new RegExp(
   'Password must include at least one of the !@#$%^&* characters.' +
   'Password must be at least 6 characters long.'; */
 
+/**
+  * returns an array of errors for a given password if it not match all the requirements
+  * 
+  * @example 
+  * ```ts
+  * const errors = DyFM_getPasswordErrors('Invalid1');
+  * console.log(errors); // ['Password must include at least one of the !@#$%^&* characters.']
+  * 
+  * const errors = DyFM_getPasswordErrors('ValidPassword1!');
+  * console.log(errors); // []
+  * ```
+  */
 export function DyFM_getPasswordErrors(password: string): string[] {
   const errors: string[] = [];
 

package/src/_collections/utils/round-list.util.ts

@@ -11,6 +11,14 @@ export class DyFM_RoundList {
    * @param listLength 
    * @param outboundIndex 
    * @returns 
+   * 
+   * @example
+   * ```ts
+   * const listLength = 10;
+   * const outboundIndex = 15;
+   * const result = DyFM_RoundList.getOutboundedIndex(listLength, outboundIndex);
+   * console.log(result); // 5
+   * ```
    */
   static getOutboundedIndex(listLength: number, outboundIndex: number): number {
     if (!listLength) {
@@ -36,6 +44,14 @@ export class DyFM_RoundList {
    * @param length 
    * @param oppositeOf 
    * @returns 
+   * 
+   * @example
+   * ```ts
+   * const length = 10;
+   * const oppositeOf = 5;
+   * const result = DyFM_RoundList.getIndexOpposite(length, oppositeOf);
+   * console.log(result); // 0
+   * ```
    */
   static getIndexOpposite(length: number, oppositeOf: number): number {
     const plusIndex = oppositeOf + Math.round(length / 2);
@@ -49,6 +65,14 @@ export class DyFM_RoundList {
    * @param list 
    * @param outboundIndex 
    * @returns 
+   * 
+   * @example
+   * ```ts
+   * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+   * const outboundIndex = 15;
+   * const result = DyFM_RoundList.getListIndex(list, outboundIndex);
+   * console.log(result); // 5
+   * ```
    */
   static getListIndex<T>(list: T[], outboundIndex: number): T {
     return list[this.getOutboundedIndex(list.length, outboundIndex)];
@@ -59,6 +83,14 @@ export class DyFM_RoundList {
    * @param list 
    * @param oppositeOf 
    * @returns 
+   * 
+   * @example
+   * ```ts
+   * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+   * const oppositeOf = 5;
+   * const result = DyFM_RoundList.getListOpposite(list, oppositeOf);
+   * console.log(result); // 0
+   * ```
    */
   static getListOpposite<T>(list: T[], oppositeOf: T): T {
     return list[this.getIndexOpposite(list.length, list.indexOf(oppositeOf))];
@@ -67,6 +99,13 @@ export class DyFM_RoundList {
   /**
    * returns the last element of the list
    * returns null if the list is empty
+   * 
+   * @example
+   * ```ts
+   * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+   * const result = DyFM_RoundList.getLast(list);
+   * console.log(result); // 10
+   * ```
    */
   static getLast<T>(list: T[]): T | null {
     if (0 < list.length) {