@itwin/core-geometry 4.0.0-dev.54 → 4.0.0-dev.56

package/lib/cjs/geometry3d/AngleSweep.d.ts

@@ -39,13 +39,15 @@ export declare class AngleSweep implements BeJSONFunctions {
     get startAngle(): Angle;
     /** Return the (strongly typed) end angle */
     get endAngle(): Angle;
-    /** Create a sweep as one of
+    /**
+     * Create a sweep as one of
      * * A clone of a given sweep
      * * 0 to given angle
      * * full circle if no arg given (sweep 0 to 360 degrees)
      */
     static create(data?: AngleSweep | Angle): AngleSweep;
-    /** (private) constructor with start and end angles in radians.
+    /**
+     * (private) constructor with start and end angles in radians.
      * * Use explicitly named static methods to clarify intent and units of inputs:
      *
      * * createStartEndRadians (startRadians:number, endRadians:number)
@@ -57,46 +59,45 @@ export declare class AngleSweep implements BeJSONFunctions {
      */
     private constructor();
     /**
-     * directly set the start and end angles in radians
+     * Directly set the start and end angles in radians
      * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.
-     * */
+     */
     setStartEndRadians(startRadians?: number, endRadians?: number): void;
-    /** directly set the start and end angles in degrees */
+    /** Directly set the start and end angles in degrees */
     setStartEndDegrees(startDegrees?: number, endDegrees?: number): void;
     /**
-     * create an AngleSweep from start and end angles given in radians.
+     * Create an AngleSweep from start and end angles given in radians.
      * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.
-     * */
+     */
     static createStartEndRadians(startRadians?: number, endRadians?: number, result?: AngleSweep): AngleSweep;
     /** Return the angle obtained by subtracting radians from this angle. */
     cloneMinusRadians(radians: number): AngleSweep;
-    /** create an AngleSweep from start and end angles given in degrees. */
+    /** Create an AngleSweep from start and end angles given in degrees. */
     static createStartEndDegrees(startDegrees?: number, endDegrees?: number, result?: AngleSweep): AngleSweep;
-    /** create an angle sweep from strongly typed start and end angles */
+    /** Create an angle sweep from strongly typed start and end angles */
     static createStartEnd(startAngle: Angle, endAngle: Angle, result?: AngleSweep): AngleSweep;
-    /** create an AngleSweep from start and end angles given in radians. */
+    /** Create an AngleSweep from start and end angles given in radians. */
     static createStartSweepRadians(startRadians?: number, sweepRadians?: number, result?: AngleSweep): AngleSweep;
-    /** create an AngleSweep from start and sweep given in degrees.  */
+    /** Create an AngleSweep from start and sweep given in degrees.  */
     static createStartSweepDegrees(startDegrees?: number, sweepDegrees?: number, result?: AngleSweep): AngleSweep;
     /** Create an angle sweep with limits given as (strongly typed) angles for start and sweep */
     static createStartSweep(startAngle: Angle, sweepAngle: Angle, result?: AngleSweep): AngleSweep;
     /** Return a sweep with limits interpolated between this and other. */
     interpolate(fraction: number, other: AngleSweep): AngleSweep;
-    /** copy from other AngleSweep. */
+    /** Copy from other AngleSweep. */
     setFrom(other: AngleSweep): void;
-    /** create a full circle sweep (CCW). startRadians defaults to 0 */
+    /** Create a full circle sweep (CCW). startRadians defaults to 0 */
     static create360(startRadians?: number): AngleSweep;
-    /** create a sweep from the south pole to the north pole (-90 to +90). */
+    /** Create a sweep from the south pole to the north pole (-90 to +90). */
     static createFullLatitude(): AngleSweep;
     /** Reverse the start and end angle in place. */
     reverseInPlace(): void;
-    /**  return a sweep for the "other" part of the circle.
+    /**
+     * Return a sweep for the "other" part of the circle.
      * @param reverseDirection true to move backwards (CW) from start to end, false to more forwards (CCW) from start to end.
      */
     cloneComplement(reverseDirection?: boolean, result?: AngleSweep): AngleSweep;
-    /**
-     * Restrict start and end angles into the range (-90,+90) in degrees.
-     * */
+    /** Restrict start and end angles into the range (-90,+90) in degrees */
     capLatitudeInPlace(): void;
     /** Ask if the sweep is counterclockwise, i.e. positive sweep */
     get isCCW(): boolean;
@@ -104,19 +105,20 @@ export declare class AngleSweep implements BeJSONFunctions {
     get isFullCircle(): boolean;
     /** Ask if the sweep is a full sweep from south pole to north pole. */
     get isFullLatitudeSweep(): boolean;
-    /** return a clone of this sweep. */
+    /** Return a clone of this sweep. */
     clone(): AngleSweep;
     /** Convert fractional position in the sweep to radians. */
     fractionToRadians(fraction: number): number;
     /** Convert fractional position in the sweep to strongly typed Angle object. */
     fractionToAngle(fraction: number): Angle;
-    /** return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
+    /**
+     * Return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
      * * This is the number of fractional intervals required to cover a whole circle.
      */
     fractionPeriod(): number;
-    /** return the fractionalized position of the given angle (as Angle) computed without consideration of
+    /**
+     * Return the fractionalized position of the given angle (as Angle) computed without consideration of
      * 2PI period and without consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -127,8 +129,8 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  does not allow period shift
      */
     angleToUnboundedFraction(theta: Angle): number;
-    /** return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  consider radians0 as `start` angle of the sweep and radians1 as `end` angle of the sweep
      * *  fraction is always positive
      * *  the start angle is at fraction 0
@@ -138,8 +140,8 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  allows period shift
      */
     static radiansToPositivePeriodicFractionStartEnd(radians: number, radians0: number, radians1: number, zeroSweepDefault?: number): number;
-    /** return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -148,8 +150,8 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  allows period shift
      */
     radiansToPositivePeriodicFraction(radians: number, zeroSweepDefault?: number): number;
-    /** return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -158,8 +160,8 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  allows period shift
      */
     angleToPositivePeriodicFraction(theta: Angle): number;
-    /** return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -168,9 +170,9 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  allows period shift
      */
     radiansArrayToPositivePeriodicFractions(data: GrowableFloat64Array): void;
-    /** return the fractionalized position of the given angle (as radian) computed with consideration of
+    /**
+     * Return the fractionalized position of the given angle (as radian) computed with consideration of
      * 2PI period and with consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -179,9 +181,9 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  allows period shift
      */
     radiansToSignedPeriodicFraction(radians: number): number;
-    /** return the fractionalized position of the given angle (as Angle) computed with consideration of
+    /**
+     * Return the fractionalized position of the given angle (as Angle) computed with consideration of
      * 2PI period and with consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -190,14 +192,14 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  allows period shift
      */
     angleToSignedPeriodicFraction(theta: Angle): number;
-    /** test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
+    /** Test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
     static isRadiansInStartEnd(radians: number, radians0: number, radians1: number, allowPeriodShift?: boolean): boolean;
-    /** test if the given angle (as radians) is within sweep  */
+    /** Test if the given angle (as radians) is within sweep  */
     isRadiansInSweep(radians: number, allowPeriodShift?: boolean): boolean;
-    /** test if the given angle (as Angle) is within the sweep */
+    /** Test if the given angle (as Angle) is within the sweep */
     isAngleInSweep(angle: Angle): boolean;
-    /** set this AngleSweep from various sources:
-     *
+    /**
+     * Set this AngleSweep from various sources:
      * * if json is undefined, a full-circle sweep is returned.
      * * If json is an AngleSweep object, it is cloned
      * * If json is an array of 2 numbers, those numbers are start and end angles in degrees.
@@ -206,22 +208,25 @@ export declare class AngleSweep implements BeJSONFunctions {
      * * Otherwise, a full-circle sweep is returned.
      */
     setFromJSON(json?: any): void;
-    /** create an AngleSweep from a json object. */
+    /** Create an AngleSweep from a json object. */
     static fromJSON(json?: AngleSweepProps): AngleSweep;
     /**
      * Convert an AngleSweep to a JSON object.
      * @return {*} {degrees: [startAngleInDegrees, endAngleInDegrees}
      */
     toJSON(): any;
-    /** test if this angle sweep and other angle sweep match with radians tolerance.
+    /**
+     * Test if this angle sweep and other angle sweep match with radians tolerance.
      * * Period shifts are allowed.
      */
     isAlmostEqualAllowPeriodShift(other: AngleSweep): boolean;
-    /** test if this angle sweep and other angle sweep match with radians tolerance.
+    /**
+     * Test if this angle sweep and other angle sweep match with radians tolerance.
      * * Period shifts are not allowed.
      */
     isAlmostEqualNoPeriodShift(other: AngleSweep): boolean;
-    /** test if start and end angles match with radians tolerance.
+    /**
+     * Test if start and end angles match with radians tolerance.
      * * Period shifts are not allowed.
      * * This function is equivalent to isAlmostEqualNoPeriodShift. It is present for consistency with other classes.
      * However, it is recommended to use isAlmostEqualNoPeriodShift which has a clearer name.

package/lib/cjs/geometry3d/AngleSweep.d.ts.map

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

package/lib/cjs/geometry3d/AngleSweep.js

@@ -59,7 +59,8 @@ class AngleSweep {
     get endAngle() {
         return Angle_1.Angle.createRadians(this._radians1);
     }
-    /** Create a sweep as one of
+    /**
+     * Create a sweep as one of
      * * A clone of a given sweep
      * * 0 to given angle
      * * full circle if no arg given (sweep 0 to 360 degrees)
@@ -71,7 +72,8 @@ class AngleSweep {
             return new AngleSweep(0, data.radians);
         return AngleSweep.create360();
     }
-    /** (private) constructor with start and end angles in radians.
+    /**
+     * (private) constructor with start and end angles in radians.
      * * Use explicitly named static methods to clarify intent and units of inputs:
      *
      * * createStartEndRadians (startRadians:number, endRadians:number)
@@ -86,9 +88,9 @@ class AngleSweep {
         this._radians1 = endRadians;
     }
     /**
-     * directly set the start and end angles in radians
+     * Directly set the start and end angles in radians
      * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.
-     * */
+     */
     setStartEndRadians(startRadians = 0, endRadians = 2.0 * Math.PI) {
         const delta = endRadians - startRadians;
         if (Angle_1.Angle.isFullCircleRadians(delta)) {
@@ -97,14 +99,14 @@ class AngleSweep {
         this._radians0 = startRadians;
         this._radians1 = endRadians;
     }
-    /** directly set the start and end angles in degrees */
+    /** Directly set the start and end angles in degrees */
     setStartEndDegrees(startDegrees = 0, endDegrees = 360.0) {
         this.setStartEndRadians(Angle_1.Angle.degreesToRadians(startDegrees), Angle_1.Angle.degreesToRadians(endDegrees));
     }
     /**
-     * create an AngleSweep from start and end angles given in radians.
+     * Create an AngleSweep from start and end angles given in radians.
      * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.
-     * */
+     */
     static createStartEndRadians(startRadians = 0, endRadians = 2.0 * Math.PI, result) {
         result = result ? result : new AngleSweep();
         result.setStartEndRadians(startRadians, endRadians);
@@ -114,23 +116,23 @@ class AngleSweep {
     cloneMinusRadians(radians) {
         return new AngleSweep(this._radians0 - radians, this._radians1 - radians);
     }
-    /** create an AngleSweep from start and end angles given in degrees. */
+    /** Create an AngleSweep from start and end angles given in degrees. */
     static createStartEndDegrees(startDegrees = 0, endDegrees = 360, result) {
         return AngleSweep.createStartEndRadians(Angle_1.Angle.degreesToRadians(startDegrees), Angle_1.Angle.degreesToRadians(endDegrees), result);
     }
-    /** create an angle sweep from strongly typed start and end angles */
+    /** Create an angle sweep from strongly typed start and end angles */
     static createStartEnd(startAngle, endAngle, result) {
         result = result ? result : new AngleSweep();
         result.setStartEndRadians(startAngle.radians, endAngle.radians);
         return result;
     }
-    /** create an AngleSweep from start and end angles given in radians. */
+    /** Create an AngleSweep from start and end angles given in radians. */
     static createStartSweepRadians(startRadians = 0, sweepRadians = Math.PI, result) {
         result = result ? result : new AngleSweep();
         result.setStartEndRadians(startRadians, startRadians + sweepRadians);
         return result;
     }
-    /** create an AngleSweep from start and sweep given in degrees.  */
+    /** Create an AngleSweep from start and sweep given in degrees.  */
     static createStartSweepDegrees(startDegrees = 0, sweepDegrees = 360, result) {
         return AngleSweep.createStartEndRadians(Angle_1.Angle.degreesToRadians(startDegrees), Angle_1.Angle.degreesToRadians(startDegrees + sweepDegrees), result);
     }
@@ -142,17 +144,17 @@ class AngleSweep {
     interpolate(fraction, other) {
         return new AngleSweep(Geometry_1.Geometry.interpolate(this._radians0, fraction, other._radians0), Geometry_1.Geometry.interpolate(this._radians1, fraction, other._radians1));
     }
-    /** copy from other AngleSweep. */
+    /** Copy from other AngleSweep. */
     setFrom(other) {
         this._radians0 = other._radians0;
         this._radians1 = other._radians1;
     }
-    /** create a full circle sweep (CCW). startRadians defaults to 0 */
+    /** Create a full circle sweep (CCW). startRadians defaults to 0 */
     static create360(startRadians) {
         startRadians = startRadians ? startRadians : 0.0;
         return new AngleSweep(startRadians, startRadians + 2.0 * Math.PI);
     }
-    /** create a sweep from the south pole to the north pole (-90 to +90). */
+    /** Create a sweep from the south pole to the north pole (-90 to +90). */
     static createFullLatitude() {
         return AngleSweep.createStartEndRadians(-0.5 * Math.PI, 0.5 * Math.PI);
     }
@@ -162,7 +164,8 @@ class AngleSweep {
         this._radians0 = this._radians1;
         this._radians1 = tmp;
     }
-    /**  return a sweep for the "other" part of the circle.
+    /**
+     * Return a sweep for the "other" part of the circle.
      * @param reverseDirection true to move backwards (CW) from start to end, false to more forwards (CCW) from start to end.
      */
     cloneComplement(reverseDirection = false, result) {
@@ -172,9 +175,7 @@ class AngleSweep {
         else
             return AngleSweep.createStartEndRadians(this.endRadians, this.startRadians + s * Math.PI, result);
     }
-    /**
-     * Restrict start and end angles into the range (-90,+90) in degrees.
-     * */
+    /** Restrict start and end angles into the range (-90,+90) in degrees */
     capLatitudeInPlace() {
         const limit = 0.5 * Math.PI;
         this._radians0 = Geometry_1.Geometry.clampToStartEnd(this._radians0, -limit, limit);
@@ -194,7 +195,7 @@ class AngleSweep {
         return Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, -a)
             && Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1, a);
     }
-    /** return a clone of this sweep. */
+    /** Return a clone of this sweep. */
     clone() {
         return new AngleSweep(this._radians0, this._radians1);
     }
@@ -208,15 +209,16 @@ class AngleSweep {
     fractionToAngle(fraction) {
         return Angle_1.Angle.createRadians(this.fractionToRadians(fraction));
     }
-    /** return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
+    /**
+     * Return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
      * * This is the number of fractional intervals required to cover a whole circle.
      */
     fractionPeriod() {
         return Geometry_1.Geometry.safeDivideFraction(Math.PI * 2.0, Math.abs(this._radians1 - this._radians0), 1.0);
     }
-    /** return the fractionalized position of the given angle (as Angle) computed without consideration of
+    /**
+     * Return the fractionalized position of the given angle (as Angle) computed without consideration of
      * 2PI period and without consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -229,8 +231,8 @@ class AngleSweep {
     angleToUnboundedFraction(theta) {
         return Geometry_1.Geometry.safeDivideFraction(theta.radians - this._radians0, this._radians1 - this._radians0, 1.0);
     }
-    /** return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  consider radians0 as `start` angle of the sweep and radians1 as `end` angle of the sweep
      * *  fraction is always positive
      * *  the start angle is at fraction 0
@@ -255,8 +257,8 @@ class AngleSweep {
         const fraction2 = Geometry_1.Geometry.safeDivideFraction(delta2, -sweep, zeroSweepDefault);
         return fraction2;
     }
-    /** return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -267,8 +269,8 @@ class AngleSweep {
     radiansToPositivePeriodicFraction(radians, zeroSweepDefault = 0.0) {
         return AngleSweep.radiansToPositivePeriodicFractionStartEnd(radians, this._radians0, this._radians1, zeroSweepDefault);
     }
-    /** return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -279,8 +281,8 @@ class AngleSweep {
     angleToPositivePeriodicFraction(theta) {
         return this.radiansToPositivePeriodicFraction(theta.radians);
     }
-    /** return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -294,9 +296,9 @@ class AngleSweep {
             data.reassign(i, this.radiansToPositivePeriodicFraction(data.atUncheckedIndex(i)));
         }
     }
-    /** return the fractionalized position of the given angle (as radian) computed with consideration of
+    /**
+     * Return the fractionalized position of the given angle (as radian) computed with consideration of
      * 2PI period and with consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -320,9 +322,9 @@ class AngleSweep {
         const fraction = 0.5 + Geometry_1.Geometry.safeDivideFraction(delta2, -sweep, 0.0);
         return fraction;
     }
-    /** return the fractionalized position of the given angle (as Angle) computed with consideration of
+    /**
+     * Return the fractionalized position of the given angle (as Angle) computed with consideration of
      * 2PI period and with consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -333,7 +335,7 @@ class AngleSweep {
     angleToSignedPeriodicFraction(theta) {
         return this.radiansToSignedPeriodicFraction(theta.radians);
     }
-    /** test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
+    /** Test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
     static isRadiansInStartEnd(radians, radians0, radians1, allowPeriodShift = true) {
         const delta0 = radians - radians0;
         const delta1 = radians - radians1;
@@ -343,16 +345,16 @@ class AngleSweep {
             return allowPeriodShift ? Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians0) : Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0);
         return allowPeriodShift ? this.radiansToPositivePeriodicFractionStartEnd(radians, radians0, radians1, 1000.0) <= 1.0 : false;
     }
-    /** test if the given angle (as radians) is within sweep  */
+    /** Test if the given angle (as radians) is within sweep  */
     isRadiansInSweep(radians, allowPeriodShift = true) {
         return AngleSweep.isRadiansInStartEnd(radians, this.startRadians, this.endRadians, allowPeriodShift);
     }
-    /** test if the given angle (as Angle) is within the sweep */
+    /** Test if the given angle (as Angle) is within the sweep */
     isAngleInSweep(angle) {
         return this.isRadiansInSweep(angle.radians);
     }
-    /** set this AngleSweep from various sources:
-     *
+    /**
+     * Set this AngleSweep from various sources:
      * * if json is undefined, a full-circle sweep is returned.
      * * If json is an AngleSweep object, it is cloned
      * * If json is an array of 2 numbers, those numbers are start and end angles in degrees.
@@ -374,7 +376,7 @@ class AngleSweep {
         else
             this.setStartEndRadians(); // default full circle
     }
-    /** create an AngleSweep from a json object. */
+    /** Create an AngleSweep from a json object. */
     static fromJSON(json) {
         const result = AngleSweep.create360();
         result.setFromJSON(json);
@@ -387,7 +389,8 @@ class AngleSweep {
     toJSON() {
         return [this.startDegrees, this.endDegrees];
     }
-    /** test if this angle sweep and other angle sweep match with radians tolerance.
+    /**
+     * Test if this angle sweep and other angle sweep match with radians tolerance.
      * * Period shifts are allowed.
      */
     isAlmostEqualAllowPeriodShift(other) {
@@ -396,14 +399,16 @@ class AngleSweep {
         return Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians0, other._radians0)
             && Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);
     }
-    /** test if this angle sweep and other angle sweep match with radians tolerance.
+    /**
+     * Test if this angle sweep and other angle sweep match with radians tolerance.
      * * Period shifts are not allowed.
      */
     isAlmostEqualNoPeriodShift(other) {
         return Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, other._radians0)
             && Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);
     }
-    /** test if start and end angles match with radians tolerance.
+    /**
+     * Test if start and end angles match with radians tolerance.
      * * Period shifts are not allowed.
      * * This function is equivalent to isAlmostEqualNoPeriodShift. It is present for consistency with other classes.
      * However, it is recommended to use isAlmostEqualNoPeriodShift which has a clearer name.