@oathompsonjones/mini-games 1.0.0

package/build/bitBoard/longInt.d.ts

@@ -0,0 +1,206 @@
+export type StringType = 2 | 10 | 16;
+/**
+ * Represents a long integer using an array of 32-bit numbers.
+ * Provides static methods for bitwise operations which do not modify the original values.
+ * Provides non-static equivalents to the above operations, which are carried out in place.
+ */
+export default class LongInt {
+    /**
+     * Holds the array of 32-bit numbers.
+     */
+    readonly data: Uint32Array;
+    /**
+     * Creates an instance of LongInt.
+     *
+     * @param values A little-endian array of 32-bit numbers to fill the `LongInt`.
+     */
+    constructor(values: number[] | Uint32Array);
+    /**
+     * Creates an instance of LongInt.
+     *
+     * @param length The number of 32-bit numbers to construct the `LongInt` out of.
+     */
+    constructor(length: number);
+    /**
+     * Creates an instance of LongInt.
+     *
+     * @param longInt A `LongInt` object to duplicate.
+     */
+    constructor(longInt: LongInt);
+    /**
+     * Gets the number of 32-bit words which make the LongInt.
+     */
+    get wordCount(): number;
+    /**
+     * Carries out a bitwise and (&) operation on the two numbers.
+     *
+     * @param left The left number.
+     * @param right The right number.
+     * @returns The result of left & right.
+     */
+    static and(left: LongInt, right: LongInt | number): LongInt;
+    /**
+     * Carries out a bitwise or (|) operation on the two numbers.
+     *
+     * @param left The left number.
+     * @param right The right number.
+     * @returns The result of left | right.
+     */
+    static or(left: LongInt, right: LongInt | number): LongInt;
+    /**
+     * Carries out a bitwise xor (^) operation on the two numbers.
+     *
+     * @param left The left number.
+     * @param right The right number.
+     * @returns The result of left ^ right.
+     */
+    static xor(left: LongInt, right: LongInt | number): LongInt;
+    /**
+     * Carries out a bitwise not (~) operation on the number.
+     *
+     * @param number The number to negate.
+     * @returns The result of ~number.
+     */
+    static not(number: LongInt): LongInt;
+    /**
+     * Carries out a bitwise left shift (<<) operation on the number.
+     *
+     * @param number The number to shift.
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of number << shiftAmount.
+     */
+    static leftShift(number: LongInt, shiftAmount: number): LongInt;
+    /**
+     * Carries out a bitwise unsigned right shift (>>>) operation on the number.
+     *
+     * @param number The number to shift.
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of number >>> shiftAmount.
+     */
+    static rightShift(number: LongInt, shiftAmount: number): LongInt;
+    /**
+     * Carries out a bitwise arithmetic right shift (>>) operation on the number.
+     *
+     * @param number The number to shift.
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of number >> shiftAmount.
+     */
+    static arithmeticRightShift(number: LongInt, shiftAmount: number): LongInt;
+    /**
+     * Determines whether or not 2 LongInts have equal values.
+     *
+     * @param longInt1 The first LongInt.
+     * @param longInt2 The second LongInt (can also be a number).
+     * @returns Whether or not they are equal.
+     */
+    static equals(longInt1: LongInt, longInt2: LongInt | number): boolean;
+    /**
+     * Creates a new LongInt object with the given value, stretched or truncated to the same size as this.
+     *
+     * @param longInt The LongInt to match the dimensions of.
+     * @param value The LongInt object to use as the value.
+     * @returns The new LongInt.
+     */
+    static getMatchingLongInt(longInt: LongInt, value: LongInt): LongInt;
+    /**
+     * Creates a new LongInt object using the given value, stretched or truncated to the same size as this.
+     *
+     * @param longInt The LongInt to match the dimensions of.
+     * @param values An array of 32-bit numbers to use as the value.
+     * @returns The new LongInt.
+     */
+    static getMatchingLongInt(longInt: LongInt, values: number[] | Uint32Array): LongInt;
+    /**
+     * Creates a new LongInt object using the given value, stretched or truncated to the same size as this.
+     *
+     * @param longInt The LongInt to match the dimensions of.
+     * @param value A 32-bit number to use as the value.
+     * @returns The new LongInt.
+     */
+    static getMatchingLongInt(longInt: LongInt, value?: number): LongInt;
+    /**
+     * Carries out an in-place bitwise and (&) operation on this number and the one provided.
+     *
+     * @param right The right number.
+     * @returns The new value of this & right.
+     */
+    and(right: LongInt | number): this;
+    /**
+     * Carries out an in-place bitwise or (|) operation on this number and the one provided.
+     *
+     * @param right The right number.
+     * @returns The new value of this | right.
+     */
+    or(right: LongInt | number): this;
+    /**
+     * Carries out an in-place bitwise xor (^) operation on this number and the one provided.
+     *
+     * @param right The right number.
+     * @returns The new value of this ^ right.
+     */
+    xor(right: LongInt | number): this;
+    /**
+     * Carries out an in-place bitwise not (~) operation on this nurmbe.
+     *
+     * @returns The result of ~this.
+     */
+    not(): this;
+    /**
+     * Carries out an in-place bitwise left shift (<<) operation on this number.
+     *
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of this << shiftAmount.
+     */
+    leftShift(shiftAmount: number): this;
+    /**
+     * Carries out an in-place bitwise unsigned right shift (>>>) operation on this number.
+     *
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of this >>> shiftAmount.
+    */
+    rightShift(shiftAmount: number): this;
+    /**
+     * Carries out an in-place bitwise arithmetic right shift (>>) operation on this number.
+     *
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of this >> shiftAmount.
+     */
+    arithmeticRightShift(shiftAmount: number): this;
+    /**
+     * Determines whether or not this LongInt has equal value to another.
+     *
+     * @param value The LongInt or number to compare to.
+     * @returns Whether or not they are equal.
+     */
+    equals(value: LongInt | number): boolean;
+    /**
+     * Returns a string representation of the LongInt.
+     *
+     * @param type The base of the string to print.
+     * @returns The string representation.
+     */
+    toString(type: StringType): string;
+    /**
+     * Creates a new LongInt object with the given value, stretched or truncated to the same size as this.
+     *
+     * @param longInt The LongInt object to use as the value.
+     * @returns The new LongInt.
+     */
+    private getMatchingLongInt;
+    /**
+     * Shifts the 32-bit number array to the right.
+     *
+     * @param count How many places to shift the array.
+     * @param fillValue The value to fill empty spaces with.
+     * @returns The new value of this.
+     */
+    private shiftArrayRight;
+    /**
+     * Shifts the 32-bit number array to the left.
+     *
+     * @param count How many places to shift the array.
+     * @param fillValue The value to fill empty spaces with.
+     * @returns The new value of this.
+     */
+    private shiftArrayLeft;
+}

package/build/bitBoard/longInt.js

@@ -0,0 +1,310 @@
+/**
+ * Represents a long integer using an array of 32-bit numbers.
+ * Provides static methods for bitwise operations which do not modify the original values.
+ * Provides non-static equivalents to the above operations, which are carried out in place.
+ */
+export default class LongInt {
+    /**
+     * Holds the array of 32-bit numbers.
+     */
+    data;
+    constructor(args) {
+        if (args instanceof Array || args instanceof Uint32Array)
+            this.data = new Uint32Array(args);
+        else if (args instanceof LongInt)
+            this.data = new Uint32Array(args.data);
+        else
+            this.data = new Uint32Array(args).fill(0);
+    }
+    /**
+     * Gets the number of 32-bit words which make the LongInt.
+     */
+    get wordCount() {
+        return this.data.length;
+    }
+    /**
+     * Carries out a bitwise and (&) operation on the two numbers.
+     *
+     * @param left The left number.
+     * @param right The right number.
+     * @returns The result of left & right.
+     */
+    static and(left, right) {
+        return new LongInt(left).and(right);
+    }
+    /**
+     * Carries out a bitwise or (|) operation on the two numbers.
+     *
+     * @param left The left number.
+     * @param right The right number.
+     * @returns The result of left | right.
+     */
+    static or(left, right) {
+        return new LongInt(left).or(right);
+    }
+    /**
+     * Carries out a bitwise xor (^) operation on the two numbers.
+     *
+     * @param left The left number.
+     * @param right The right number.
+     * @returns The result of left ^ right.
+     */
+    static xor(left, right) {
+        return new LongInt(left).xor(right);
+    }
+    /**
+     * Carries out a bitwise not (~) operation on the number.
+     *
+     * @param number The number to negate.
+     * @returns The result of ~number.
+     */
+    static not(number) {
+        return new LongInt(number).not();
+    }
+    /**
+     * Carries out a bitwise left shift (<<) operation on the number.
+     *
+     * @param number The number to shift.
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of number << shiftAmount.
+     */
+    static leftShift(number, shiftAmount) {
+        return new LongInt(number).leftShift(shiftAmount);
+    }
+    /**
+     * Carries out a bitwise unsigned right shift (>>>) operation on the number.
+     *
+     * @param number The number to shift.
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of number >>> shiftAmount.
+     */
+    static rightShift(number, shiftAmount) {
+        return new LongInt(number).rightShift(shiftAmount);
+    }
+    /**
+     * Carries out a bitwise arithmetic right shift (>>) operation on the number.
+     *
+     * @param number The number to shift.
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of number >> shiftAmount.
+     */
+    static arithmeticRightShift(number, shiftAmount) {
+        return new LongInt(number).arithmeticRightShift(shiftAmount);
+    }
+    /**
+     * Determines whether or not 2 LongInts have equal values.
+     *
+     * @param longInt1 The first LongInt.
+     * @param longInt2 The second LongInt (can also be a number).
+     * @returns Whether or not they are equal.
+     */
+    static equals(longInt1, longInt2) {
+        return longInt1.equals(longInt2);
+    }
+    static getMatchingLongInt(longInt, value = 0) {
+        return new LongInt(longInt).getMatchingLongInt(value);
+    }
+    /**
+     * Carries out an in-place bitwise and (&) operation on this number and the one provided.
+     *
+     * @param right The right number.
+     * @returns The new value of this & right.
+     */
+    and(right) {
+        const rightLongInt = this.getMatchingLongInt(right);
+        for (let i = 0; i < this.data.length; i++)
+            this.data[i] &= rightLongInt.data[i];
+        return this;
+    }
+    /**
+     * Carries out an in-place bitwise or (|) operation on this number and the one provided.
+     *
+     * @param right The right number.
+     * @returns The new value of this | right.
+     */
+    or(right) {
+        const rightLongInt = this.getMatchingLongInt(right);
+        for (let i = 0; i < this.data.length; i++)
+            this.data[i] |= rightLongInt.data[i];
+        return this;
+    }
+    /**
+     * Carries out an in-place bitwise xor (^) operation on this number and the one provided.
+     *
+     * @param right The right number.
+     * @returns The new value of this ^ right.
+     */
+    xor(right) {
+        const rightLongInt = this.getMatchingLongInt(right);
+        for (let i = 0; i < this.data.length; i++)
+            this.data[i] ^= rightLongInt.data[i];
+        return this;
+    }
+    /**
+     * Carries out an in-place bitwise not (~) operation on this nurmbe.
+     *
+     * @returns The result of ~this.
+     */
+    not() {
+        for (let i = 0; i < this.data.length; i++)
+            this.data[i] = ~this.data[i];
+        return this;
+    }
+    /**
+     * Carries out an in-place bitwise left shift (<<) operation on this number.
+     *
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of this << shiftAmount.
+     */
+    leftShift(shiftAmount) {
+        if (shiftAmount === 0)
+            return this;
+        if (shiftAmount > 31)
+            this.shiftArrayRight(Math.floor(shiftAmount / 32));
+        if (shiftAmount !== 32) {
+            const singleShiftAmount = shiftAmount % 32;
+            for (let i = this.data.length - 1; i >= 0; i--)
+                this.data[i] = this.data[i] << singleShiftAmount | this.data[i - 1] >>> 32 - singleShiftAmount;
+        }
+        return this;
+    }
+    /**
+     * Carries out an in-place bitwise unsigned right shift (>>>) operation on this number.
+     *
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of this >>> shiftAmount.
+    */
+    rightShift(shiftAmount) {
+        if (shiftAmount === 0)
+            return this;
+        if (shiftAmount !== 32) {
+            const singleShiftAmount = shiftAmount % 32;
+            for (let i = 0; i < this.data.length; i++)
+                this.data[i] = this.data[i] >>> singleShiftAmount | this.data[i + 1] << 32 - singleShiftAmount;
+        }
+        if (shiftAmount > 31)
+            this.shiftArrayLeft(Math.floor(shiftAmount / 32));
+        return this;
+    }
+    /**
+     * Carries out an in-place bitwise arithmetic right shift (>>) operation on this number.
+     *
+     * @param shiftAmount The number of places to shift.
+     * @returns The result of this >> shiftAmount.
+     */
+    arithmeticRightShift(shiftAmount) {
+        if (shiftAmount === 0)
+            return this;
+        if (shiftAmount !== 32) {
+            const singleShiftAmount = shiftAmount % 32;
+            for (let i = 0; i < this.data.length; i++)
+                this.data[i] = this.data[i] >> singleShiftAmount | this.data[i + 1] << 32 - singleShiftAmount;
+        }
+        if (shiftAmount > 31)
+            this.shiftArrayLeft(Math.floor(shiftAmount / 32), ~0 >>> 0);
+        return this;
+    }
+    /**
+     * Determines whether or not this LongInt has equal value to another.
+     *
+     * @param value The LongInt or number to compare to.
+     * @returns Whether or not they are equal.
+     */
+    equals(value) {
+        const longInt = value instanceof LongInt ? value : new LongInt([value]);
+        const longestLongInt = this.data.length > longInt.data.length ? this : longInt;
+        const longInt1 = LongInt.getMatchingLongInt(longestLongInt, this);
+        const longInt2 = LongInt.getMatchingLongInt(longestLongInt, longInt);
+        for (let i = 0; i < longestLongInt.data.length; i++) {
+            if (longInt1.data[i] !== longInt2.data[i])
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Returns a string representation of the LongInt.
+     *
+     * @param type The base of the string to print.
+     * @returns The string representation.
+     */
+    toString(type) {
+        let padLength = 0;
+        switch (type) {
+            case 2:
+                padLength = 32;
+                break;
+            case 10:
+                padLength = 10;
+                break;
+            case 16:
+                padLength = 8;
+                break;
+        }
+        return [...this.data]
+            .reverse()
+            .map((num) => num.toString(type).padStart(padLength, "0"))
+            .join(" ");
+    }
+    getMatchingLongInt(value = 0) {
+        let integers = [];
+        switch (true) {
+            case value instanceof Uint32Array:
+                if (value.length < this.data.length)
+                    integers = [...value, ...Array(this.data.length - value.length).fill(0)];
+                else if (value.length > this.data.length)
+                    integers = value.slice(0, this.data.length);
+                else
+                    integers = value;
+                break;
+            case value instanceof LongInt:
+                if (value.data.length < this.data.length)
+                    integers = [...value.data, ...Array(this.data.length - value.data.length).fill(0)];
+                else if (value.data.length > this.data.length)
+                    integers = value.data.slice(0, this.data.length);
+                else
+                    integers = value.data;
+                break;
+            case value instanceof Array:
+                if (value.length < this.data.length)
+                    integers = [...value, ...Array(this.data.length - value.length).fill(0)];
+                else if (value.length > this.data.length)
+                    integers = value.slice(0, this.data.length);
+                else
+                    integers = value;
+                break;
+            default:
+                integers = [value, ...Array(this.data.length - 1).fill(0)];
+                break;
+        }
+        return new LongInt(integers);
+    }
+    /**
+     * Shifts the 32-bit number array to the right.
+     *
+     * @param count How many places to shift the array.
+     * @param fillValue The value to fill empty spaces with.
+     * @returns The new value of this.
+     */
+    shiftArrayRight(count, fillValue = 0) {
+        if (count < 0)
+            return this.shiftArrayLeft(-count, fillValue);
+        for (let i = this.data.length - 1; i >= 0; i--)
+            this.data[i] = this.data[i - count] ?? fillValue;
+        return this;
+    }
+    /**
+     * Shifts the 32-bit number array to the left.
+     *
+     * @param count How many places to shift the array.
+     * @param fillValue The value to fill empty spaces with.
+     * @returns The new value of this.
+     */
+    shiftArrayLeft(count, fillValue = 0) {
+        if (count < 0)
+            return this.shiftArrayRight(-count, fillValue);
+        for (let i = 0; i < this.data.length; i++)
+            this.data[i] = this.data[i + count] ?? fillValue;
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"longInt.js","sourceRoot":"","sources":["../../src/bitBoard/longInt.ts"],"names":[],"mappings":"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","sourcesContent":["export type StringType = 2 | 10 | 16;\n\n/**\n * Represents a long integer using an array of 32-bit numbers.\n * Provides static methods for bitwise operations which do not modify the original values.\n * Provides non-static equivalents to the above operations, which are carried out in place.\n */\nexport default class LongInt {\n    /**\n     * Holds the array of 32-bit numbers.\n     */\n    public readonly data: Uint32Array;\n\n    /**\n     * Creates an instance of LongInt.\n     *\n     * @param values A little-endian array of 32-bit numbers to fill the `LongInt`.\n     */\n    public constructor(values: number[] | Uint32Array);\n    /**\n     * Creates an instance of LongInt.\n     *\n     * @param length The number of 32-bit numbers to construct the `LongInt` out of.\n     */\n    public constructor(length: number);\n    /**\n     * Creates an instance of LongInt.\n     *\n     * @param longInt A `LongInt` object to duplicate.\n     */\n    public constructor(longInt: LongInt);\n    public constructor(args: LongInt | number[] | Uint32Array | number) {\n        if (args instanceof Array || args instanceof Uint32Array)\n            this.data = new Uint32Array(args);\n        else if (args instanceof LongInt)\n            this.data = new Uint32Array(args.data);\n        else\n            this.data = new Uint32Array(args).fill(0);\n    }\n\n    /**\n     * Gets the number of 32-bit words which make the LongInt.\n     */\n    public get wordCount(): number {\n        return this.data.length;\n    }\n\n    /**\n     * Carries out a bitwise and (&) operation on the two numbers.\n     *\n     * @param left The left number.\n     * @param right The right number.\n     * @returns The result of left & right.\n     */\n    public static and(left: LongInt, right: LongInt | number): LongInt {\n        return new LongInt(left).and(right);\n    }\n\n    /**\n     * Carries out a bitwise or (|) operation on the two numbers.\n     *\n     * @param left The left number.\n     * @param right The right number.\n     * @returns The result of left | right.\n     */\n    public static or(left: LongInt, right: LongInt | number): LongInt {\n        return new LongInt(left).or(right);\n    }\n\n    /**\n     * Carries out a bitwise xor (^) operation on the two numbers.\n     *\n     * @param left The left number.\n     * @param right The right number.\n     * @returns The result of left ^ right.\n     */\n    public static xor(left: LongInt, right: LongInt | number): LongInt {\n        return new LongInt(left).xor(right);\n    }\n\n    /**\n     * Carries out a bitwise not (~) operation on the number.\n     *\n     * @param number The number to negate.\n     * @returns The result of ~number.\n     */\n    public static not(number: LongInt): LongInt {\n        return new LongInt(number).not();\n    }\n\n    /**\n     * Carries out a bitwise left shift (<<) operation on the number.\n     *\n     * @param number The number to shift.\n     * @param shiftAmount The number of places to shift.\n     * @returns The result of number << shiftAmount.\n     */\n    public static leftShift(number: LongInt, shiftAmount: number): LongInt {\n        return new LongInt(number).leftShift(shiftAmount);\n    }\n\n    /**\n     * Carries out a bitwise unsigned right shift (>>>) operation on the number.\n     *\n     * @param number The number to shift.\n     * @param shiftAmount The number of places to shift.\n     * @returns The result of number >>> shiftAmount.\n     */\n    public static rightShift(number: LongInt, shiftAmount: number): LongInt {\n        return new LongInt(number).rightShift(shiftAmount);\n    }\n\n    /**\n     * Carries out a bitwise arithmetic right shift (>>) operation on the number.\n     *\n     * @param number The number to shift.\n     * @param shiftAmount The number of places to shift.\n     * @returns The result of number >> shiftAmount.\n     */\n    public static arithmeticRightShift(number: LongInt, shiftAmount: number): LongInt {\n        return new LongInt(number).arithmeticRightShift(shiftAmount);\n    }\n\n    /**\n     * Determines whether or not 2 LongInts have equal values.\n     *\n     * @param longInt1 The first LongInt.\n     * @param longInt2 The second LongInt (can also be a number).\n     * @returns Whether or not they are equal.\n     */\n    public static equals(longInt1: LongInt, longInt2: LongInt | number): boolean {\n        return longInt1.equals(longInt2);\n    }\n\n    /**\n     * Creates a new LongInt object with the given value, stretched or truncated to the same size as this.\n     *\n     * @param longInt The LongInt to match the dimensions of.\n     * @param value The LongInt object to use as the value.\n     * @returns The new LongInt.\n     */\n    public static getMatchingLongInt(longInt: LongInt, value: LongInt): LongInt;\n    /**\n     * Creates a new LongInt object using the given value, stretched or truncated to the same size as this.\n     *\n     * @param longInt The LongInt to match the dimensions of.\n     * @param values An array of 32-bit numbers to use as the value.\n     * @returns The new LongInt.\n     */\n    public static getMatchingLongInt(longInt: LongInt, values: number[] | Uint32Array): LongInt;\n    /**\n     * Creates a new LongInt object using the given value, stretched or truncated to the same size as this.\n     *\n     * @param longInt The LongInt to match the dimensions of.\n     * @param value A 32-bit number to use as the value.\n     * @returns The new LongInt.\n     */\n    public static getMatchingLongInt(longInt: LongInt, value?: number): LongInt;\n    public static getMatchingLongInt(longInt: LongInt, value: LongInt | number[] | Uint32Array | number = 0): LongInt {\n        return new LongInt(longInt).getMatchingLongInt(value);\n    }\n\n    /**\n     * Carries out an in-place bitwise and (&) operation on this number and the one provided.\n     *\n     * @param right The right number.\n     * @returns The new value of this & right.\n     */\n    public and(right: LongInt | number): this {\n        const rightLongInt = this.getMatchingLongInt(right);\n        for (let i = 0; i < this.data.length; i++)\n            this.data[i] &= rightLongInt.data[i]!;\n        return this;\n    }\n\n    /**\n     * Carries out an in-place bitwise or (|) operation on this number and the one provided.\n     *\n     * @param right The right number.\n     * @returns The new value of this | right.\n     */\n    public or(right: LongInt | number): this {\n        const rightLongInt = this.getMatchingLongInt(right);\n        for (let i = 0; i < this.data.length; i++)\n            this.data[i] |= rightLongInt.data[i]!;\n        return this;\n    }\n\n    /**\n     * Carries out an in-place bitwise xor (^) operation on this number and the one provided.\n     *\n     * @param right The right number.\n     * @returns The new value of this ^ right.\n     */\n    public xor(right: LongInt | number): this {\n        const rightLongInt = this.getMatchingLongInt(right);\n        for (let i = 0; i < this.data.length; i++)\n            this.data[i] ^= rightLongInt.data[i]!;\n        return this;\n    }\n\n    /**\n     * Carries out an in-place bitwise not (~) operation on this nurmbe.\n     *\n     * @returns The result of ~this.\n     */\n    public not(): this {\n        for (let i = 0; i < this.data.length; i++)\n            this.data[i] = ~this.data[i]!;\n        return this;\n    }\n\n    /**\n     * Carries out an in-place bitwise left shift (<<) operation on this number.\n     *\n     * @param shiftAmount The number of places to shift.\n     * @returns The result of this << shiftAmount.\n     */\n    public leftShift(shiftAmount: number): this {\n        if (shiftAmount === 0)\n            return this;\n        if (shiftAmount > 31)\n            this.shiftArrayRight(Math.floor(shiftAmount / 32));\n        if (shiftAmount !== 32) {\n            const singleShiftAmount = shiftAmount % 32;\n            for (let i = this.data.length - 1; i >= 0; i--)\n                this.data[i] = this.data[i]! << singleShiftAmount | this.data[i - 1]! >>> 32 - singleShiftAmount;\n        }\n        return this;\n    }\n\n    /**\n     * Carries out an in-place bitwise unsigned right shift (>>>) operation on this number.\n     *\n     * @param shiftAmount The number of places to shift.\n     * @returns The result of this >>> shiftAmount.\n    */\n    public rightShift(shiftAmount: number): this {\n        if (shiftAmount === 0)\n            return this;\n        if (shiftAmount !== 32) {\n            const singleShiftAmount = shiftAmount % 32;\n            for (let i = 0; i < this.data.length; i++)\n                this.data[i] = this.data[i]! >>> singleShiftAmount | this.data[i + 1]! << 32 - singleShiftAmount;\n        }\n        if (shiftAmount > 31)\n            this.shiftArrayLeft(Math.floor(shiftAmount / 32));\n        return this;\n    }\n\n    /**\n     * Carries out an in-place bitwise arithmetic right shift (>>) operation on this number.\n     *\n     * @param shiftAmount The number of places to shift.\n     * @returns The result of this >> shiftAmount.\n     */\n    public arithmeticRightShift(shiftAmount: number): this {\n        if (shiftAmount === 0)\n            return this;\n        if (shiftAmount !== 32) {\n            const singleShiftAmount = shiftAmount % 32;\n            for (let i = 0; i < this.data.length; i++)\n                this.data[i] = this.data[i]! >> singleShiftAmount | this.data[i + 1]! << 32 - singleShiftAmount;\n        }\n        if (shiftAmount > 31)\n            this.shiftArrayLeft(Math.floor(shiftAmount / 32), ~0 >>> 0);\n        return this;\n    }\n\n    /**\n     * Determines whether or not this LongInt has equal value to another.\n     *\n     * @param value The LongInt or number to compare to.\n     * @returns Whether or not they are equal.\n     */\n    public equals(value: LongInt | number): boolean {\n        const longInt = value instanceof LongInt ? value : new LongInt([value]);\n        const longestLongInt = this.data.length > longInt.data.length ? this : longInt;\n        const longInt1 = LongInt.getMatchingLongInt(longestLongInt, this);\n        const longInt2 = LongInt.getMatchingLongInt(longestLongInt, longInt);\n        for (let i = 0; i < longestLongInt.data.length; i++) {\n            if (longInt1.data[i] !== longInt2.data[i])\n                return false;\n        }\n        return true;\n    }\n\n    /**\n     * Returns a string representation of the LongInt.\n     *\n     * @param type The base of the string to print.\n     * @returns The string representation.\n     */\n    public toString(type: StringType): string {\n        let padLength = 0;\n        switch (type) {\n            case 2:\n                padLength = 32;\n                break;\n            case 10:\n                padLength = 10;\n                break;\n            case 16:\n                padLength = 8;\n                break;\n        }\n        return [...this.data]\n            .reverse()\n            .map((num) => num.toString(type).padStart(padLength, \"0\"))\n            .join(\" \");\n    }\n\n    /**\n     * Creates a new LongInt object with the given value, stretched or truncated to the same size as this.\n     *\n     * @param longInt The LongInt object to use as the value.\n     * @returns The new LongInt.\n     */\n    private getMatchingLongInt(longInt: LongInt): LongInt;\n    /**\n     * Creates a new LongInt object using the given value, stretched or truncated to the same size as this.\n     *\n     * @param values An array of 32-bit numbers to use as the value.\n     * @returns The new LongInt.\n     */\n    private getMatchingLongInt(values: number[] | Uint32Array): LongInt;\n    /**\n     * Creates a new LongInt object using the given value, stretched or truncated to the same size as this.\n     *\n     * @param value A 32-bit number to use as the value.\n     * @returns The new LongInt.\n     */\n    private getMatchingLongInt(value?: number): LongInt;\n    /**\n     * Creates a LongInt with the same dimensions as this one, using the given input.\n     *\n     * @param value The value of the LongInt.\n     * @returns The new LongInt.\n     */\n    private getMatchingLongInt(value: LongInt | number[] | Uint32Array | number): LongInt;\n    private getMatchingLongInt(value: LongInt | number[] | Uint32Array | number = 0): LongInt {\n        let integers: number[] | Uint32Array = [];\n        switch (true) {\n            case value instanceof Uint32Array:\n                if (value.length < this.data.length)\n                    integers = [...value, ...Array<number>(this.data.length - value.length).fill(0)];\n                else if (value.length > this.data.length)\n                    integers = value.slice(0, this.data.length);\n                else\n                    integers = value;\n                break;\n            case value instanceof LongInt:\n                if (value.data.length < this.data.length)\n                    integers = [...value.data, ...Array<number>(this.data.length - value.data.length).fill(0)];\n                else if (value.data.length > this.data.length)\n                    integers = value.data.slice(0, this.data.length);\n                else\n                    integers = value.data;\n                break;\n            case value instanceof Array:\n                if (value.length < this.data.length)\n                    integers = [...value, ...Array<number>(this.data.length - value.length).fill(0)];\n                else if (value.length > this.data.length)\n                    integers = value.slice(0, this.data.length);\n                else\n                    integers = value;\n                break;\n            default:\n                integers = [value, ...Array<number>(this.data.length - 1).fill(0)];\n                break;\n        }\n        return new LongInt(integers);\n    }\n\n    /**\n     * Shifts the 32-bit number array to the right.\n     *\n     * @param count How many places to shift the array.\n     * @param fillValue The value to fill empty spaces with.\n     * @returns The new value of this.\n     */\n    private shiftArrayRight(count: number, fillValue: number = 0): this {\n        if (count < 0)\n            return this.shiftArrayLeft(-count, fillValue);\n        for (let i = this.data.length - 1; i >= 0; i--)\n            this.data[i] = this.data[i - count] ?? fillValue;\n        return this;\n    }\n\n    /**\n     * Shifts the 32-bit number array to the left.\n     *\n     * @param count How many places to shift the array.\n     * @param fillValue The value to fill empty spaces with.\n     * @returns The new value of this.\n     */\n    private shiftArrayLeft(count: number, fillValue: number = 0): this {\n        if (count < 0)\n            return this.shiftArrayRight(-count, fillValue);\n        for (let i = 0; i < this.data.length; i++)\n            this.data[i] = this.data[i + count] ?? fillValue;\n        return this;\n    }\n}\n"]}

package/build/bitBoard/longIntBitBoard.d.ts

@@ -0,0 +1,46 @@
+import BitBoard from "./bitBoard.js";
+import LongInt from "./longInt.js";
+/**
+ * A BitBoard which uses an array of 32-bit numbers.
+ */
+export default class LongIntBitBoard extends BitBoard<LongInt> {
+    /**
+     * Creates an instance of LongIntBitBoard.
+     *
+     * @param longInt The data to fill the BitBoard with.
+    */
+    constructor(longInt: LongInt);
+    /**
+     * Creates an instance of LongIntBitBoard.
+     *
+     * @param uint32Array The data to fill the BitBoard with.
+     */
+    constructor(uint32Array: Uint32Array);
+    /**
+     * Creates an instance of LongIntBitBoard.
+     *
+     * @param numberArray The data to fill the BitBoard with.
+     */
+    constructor(numberArray: number[]);
+    /**
+     * Creates an instance of LongIntBitBoard.
+     *
+     * @param length The length of the LongInt.
+     */
+    constructor(length: number);
+    getBit(bit: number): 0 | 1;
+    setBit(bit: number): void;
+    clearBit(bit: number): void;
+    toggleBit(bit: number): void;
+    clearAll(): void;
+    setAll(): void;
+    getBits(LSB: number, numberOfBits: number): LongInt;
+    and(right: LongIntBitBoard | number): this;
+    or(right: LongIntBitBoard | number): this;
+    xor(right: LongIntBitBoard | number): this;
+    not(): this;
+    leftShift(shiftAmount: number): this;
+    rightShift(shiftAmount: number): this;
+    arithmeticRightShift(shiftAmount: number): this;
+    equals(value: LongInt | LongIntBitBoard | number): boolean;
+}