@futdevpro/fsm-dynamo 1.20.92 → 1.20.94

package/build-esm/_collections/utils/log.util.js

@@ -0,0 +1,555 @@
+import { DyFM_LogStyle, DyFM_allLogStyles } from '../../_enums/log-style.enum';
+/**
+ * DyFM_Log is a class that provides a set of methods to log messages to the console.
+ * This class have methods to log messages with different styles and colors,
+ * such as success, error, warn, info and highlighted for each of them.
+ */
+export class DyFM_Log {
+    static infoStyle = DyFM_LogStyle.cyan;
+    static errorStyle = DyFM_LogStyle.red;
+    static warnStyle = DyFM_LogStyle.brightOrange;
+    static successStyle = DyFM_LogStyle.green;
+    static highlightedStyle = `${DyFM_LogStyle.white}${DyFM_LogStyle.bold}`;
+    static boldStyle = DyFM_LogStyle.bold;
+    static h_test = '||||||||||';
+    static h_before = '\\\\\\\\\\\\\\\\\\\\';
+    static h_after = '//////////';
+    static h_small = '----------';
+    /**
+     * Sets the style of the console log.
+     * @param styles - The styles to set.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.setStyle([ DyFM_LogStyle.bold, DyFM_LogStyle.underline ]);
+     * ```
+     */
+    static setStyle(styles) {
+        let styleSets = '';
+        styles.forEach((style) => {
+            styleSets += style;
+        });
+        console.log(styleSets);
+    }
+    /**
+     * Resets the style of the console log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.resetStyle();
+     * ```
+     */
+    static resetStyle() {
+        console.log(DyFM_LogStyle.reset);
+    }
+    /**
+     * Adds a style to the console log.
+     * @param input - The input to add the style to.
+     * @param styles - The styles to add.
+     * @param dontReset - Whether to not reset the style.
+     * @returns The input with the style added.
+     *
+     * @example
+     * ```ts
+     * const result = DyFM_Log.addStyle('Hello, world!', [ DyFM_LogStyle.bold, DyFM_LogStyle.underline ]);
+     * ```
+     */
+    static addStyle(input, styles, dontReset) {
+        let result = '';
+        styles.forEach((style) => {
+            result += style;
+        });
+        result += input;
+        if (!dontReset) {
+            result += DyFM_LogStyle.reset;
+        }
+        return result;
+    }
+    /**
+     * Logs a success message.
+     * @param message - The message to log.
+     * @param optionalParams - The optional parameters to log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.success('Hello, world!');
+     * ```
+     */
+    static success(message, ...optionalParams) {
+        if (0 < optionalParams.length) {
+            console.log(`${this.successStyle}${message}`, ...optionalParams, DyFM_LogStyle.reset);
+        }
+        else {
+            console.log(`${this.successStyle}${message}${DyFM_LogStyle.reset}`);
+        }
+    }
+    /**
+     * @deprecated use DyFM_Log.success instead
+     */
+    static logSuccess = this.success;
+    /**
+     * Logs an error message.
+     * @param message - The message to log.
+     * @param optionalParams - The optional parameters to log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.error('An error occurred: {errorMessage}', errorMessage);
+     * ```
+     */
+    static error(message, ...optionalParams) {
+        if (0 < optionalParams.length) {
+            console.error(`${this.errorStyle}${message}`, ...optionalParams, DyFM_LogStyle.reset);
+        }
+        else {
+            console.error(`${this.errorStyle}${message}${DyFM_LogStyle.reset}`);
+        }
+    }
+    /**
+     * @deprecated use DyFM_Log.error instead
+     */
+    static logError = this.error;
+    /**
+     * Logs a warning message.
+     * @param message - The message to log.
+     * @param optionalParams - The optional parameters to log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.warn('A warning occurred: {warningMessage}', warningMessage);
+     * ```
+     */
+    static warn(message, ...optionalParams) {
+        if (0 < optionalParams.length) {
+            console.warn(`${this.warnStyle}${message}`, ...optionalParams, DyFM_LogStyle.reset);
+        }
+        else {
+            console.warn(`${this.warnStyle}${message}${DyFM_LogStyle.reset}`);
+        }
+    }
+    /**
+     * @deprecated use DyFM_Log.warn instead
+     */
+    static warning = this.warn;
+    /**
+     * @deprecated use DyFM_Log.warn instead
+     */
+    static logWarning = this.warn;
+    // ez azért nem egy sima "static readonly info = console.info;", 
+    // mert azon nincs rajta az első input típusa, ami csak string lehet
+    /**
+     * Logs an info message.
+     * @param message - The message to log.
+     * @param optionalParams - The optional parameters to log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.info('An info message: {infoMessage}', infoMessage);
+     * ```
+     */
+    static info(message, ...optionalParams) {
+        if (0 < optionalParams.length) {
+            console.info(`${this.infoStyle}${message}`, ...optionalParams, DyFM_LogStyle.reset);
+        }
+        else {
+            console.info(`${this.infoStyle}${message}${DyFM_LogStyle.reset}`);
+        }
+    }
+    // ez azért nem egy sima "static readonly log = console.log;", 
+    // mert azon nincs rajta az első input típusa, ami csak string lehet
+    /**
+     * Logs a log message.
+     * @param message - The message to log.
+     * @param optionalParams - The optional parameters to log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.log('A log message: {logMessage}', logMessage);
+     * ```
+     */
+    static log(message, ...optionalParams) {
+        console.log(message, ...optionalParams);
+    }
+    /**
+     * Gets a highlighted message.
+     * @param message - The message to highlight.
+     * @param optionalParams - The optional parameters to highlight.
+     * @returns The highlighted message.
+     *
+     * @example
+     * ```ts
+     * const highlightedMessage = DyFM_Log.getHighlighted('A highlighted message: {highlightedMessage}', highlightedMessage);
+     * console.log(highlightedMessage); // A highlighted message: {highlightedMessage}
+     * ```
+     */
+    static getHighlighted(message, ...optionalParams) {
+        return `${this.highlightedStyle}${message}${DyFM_LogStyle.reset}`;
+    }
+    /**
+     * Logs a highlighted message.
+     * @param message - The message to highlight.
+     * @param optionalParams - The optional parameters to highlight.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.highlighted('A highlighted message: {highlightedMessage}', highlightedMessage);
+     * ```
+     */
+    static highlighted(message, ...optionalParams) {
+        if (0 < optionalParams.length) {
+            console.log(`${this.highlightedStyle}${message}`, ...optionalParams, DyFM_LogStyle.reset);
+        }
+        else {
+            console.log(`${this.highlightedStyle}${message}${DyFM_LogStyle.reset}`);
+        }
+    }
+    /**
+     * Logs a small Highlighted log message.
+     * @param message - The message to log.
+     * @param optionalParams - The optional parameters to log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.smallLog('A small log message: {smallLogMessage}', smallLogMessage);
+     * ```
+     */
+    static smallLog(message, ...optionalParams) {
+        console.log(this.h_small +
+            '\n  ' + this.asfel(message, 2), ...this.asfesop(optionalParams, 2), '\n' + this.h_small);
+    }
+    static S_log = DyFM_Log.smallLog;
+    /**
+     * Highlighted Tests a log message.
+     * @param message - The message to test.
+     * @param optionalParams - The optional parameters to test.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.testLog('A test log message: {testLogMessage}', testLogMessage);
+     * ```
+     */
+    static testLog(message, ...optionalParams) {
+        this.log('\n' + this.h_test +
+            '\n\n    ' + this.asfel(message, 4), ...this.asfesop(optionalParams, 4), '\n\n' + this.h_test + '\n');
+    }
+    static test = DyFM_Log.testLog;
+    static T_log = DyFM_Log.testLog;
+    /**
+     * Logs a highlighted log message.
+     * @param message - The message to highlight.
+     * @param optionalParams - The optional parameters to highlight.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.highlightedLog('A highlighted log message: {highlightedLogMessage}', highlightedLogMessage);
+     * ```
+     */
+    static highlightedLog(message, ...optionalParams) {
+        this.log('\n\n' + this.h_before +
+            '\n ' + this.h_before +
+            '\n  ' + this.h_before +
+            '\n\n    ' + this.asfel(message, 4), ...this.asfesop(optionalParams, 4), '\n\n  ' + this.h_after +
+            '\n ' + this.h_after +
+            '\n' + this.h_after + '\n\n');
+    }
+    static H_log = DyFM_Log.highlightedLog;
+    /**
+     * Logs a small Highlighted info message.
+     * @param message - The message to log.
+     * @param optionalParams - The optional parameters to log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.smallInfo('A small info message: {smallInfoMessage}', smallInfoMessage);
+     * ```
+     */
+    static smallInfo(message, ...optionalParams) {
+        this.info(this.h_small +
+            '\n  ' + this.asfel(message, 2), ...this.asfesop(optionalParams, 2), '\n' + this.infoStyle + this.h_small);
+    }
+    static S_info = DyFM_Log.smallInfo;
+    /**
+     * Highlighted Tests an info message.
+     * @param message - The message to test.
+     * @param optionalParams - The optional parameters to test.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.testInfo('A test info message: {testInfoMessage}', testInfoMessage);
+     * ```
+     */
+    static testInfo(message, ...optionalParams) {
+        this.info('\n' + this.h_test +
+            '\n\n    ' + this.asfel(message, 4), ...this.asfesop(optionalParams, 4), '\n\n' + this.infoStyle + this.h_test + '\n');
+    }
+    static T_info = DyFM_Log.testInfo;
+    /**
+     * Logs a highlighted info message.
+     * @param message - The message to highlight.
+     * @param optionalParams - The optional parameters to highlight.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.highlightedInfo('A highlighted info message: {highlightedInfoMessage}', highlightedInfoMessage);
+     * ```
+     */
+    static highlightedInfo(message, ...optionalParams) {
+        this.info('\n\n' + this.h_before +
+            '\n ' + this.h_before +
+            '\n  ' + this.h_before +
+            '\n\n    ' + this.asfel(message, 4), ...this.asfesop(optionalParams, 4), '\n\n  ' + this.infoStyle + this.h_after +
+            '\n ' + this.h_after +
+            '\n' + this.h_after + '\n\n');
+    }
+    static H_info = DyFM_Log.highlightedInfo;
+    /**
+     * Logs a small Highlighted error message.
+     * @param message - The message to log.
+     * @param optionalParams - The optional parameters to log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.smallError('A small error message: {smallErrorMessage}', smallErrorMessage);
+     * ```
+     */
+    static smallError(message, ...optionalParams) {
+        this.error(this.h_small +
+            '\n  ' + this.asfel(message, 2), ...this.asfesop(optionalParams, 2), '\n' + this.errorStyle + this.h_small);
+    }
+    static S_error = DyFM_Log.smallError;
+    /**
+     * Highlighted Tests an error message.
+     * @param message - The message to test.
+     * @param optionalParams - The optional parameters to test.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.testError('A test error message: {testErrorMessage}', testErrorMessage);
+     * ```
+     */
+    static testError(message, ...optionalParams) {
+        this.error('\n' + this.h_test +
+            '\n\n    ' + this.asfel(message, 4), ...this.asfesop(optionalParams, 4), '\n\n' + this.errorStyle + this.h_test + '\n');
+    }
+    static T_error = DyFM_Log.testError;
+    /**
+     * Logs a highlighted error message.
+     * @param message - The message to highlight.
+     * @param optionalParams - The optional parameters to highlight.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.highlightedError('A highlighted error message: {highlightedErrorMessage}', highlightedErrorMessage);
+     * ```
+     */
+    static highlightedError(message, ...optionalParams) {
+        this.error('\n\n' + this.h_before +
+            '\n ' + this.h_before +
+            '\n  ' + this.h_before +
+            '\n\n    ' + this.asfel(message, 4), ...this.asfesop(optionalParams, 4), '\n\n  ' + this.errorStyle + this.h_after +
+            '\n ' + this.h_after +
+            '\n' + this.h_after + '\n\n');
+    }
+    static H_error = DyFM_Log.highlightedError;
+    /**
+     * Logs a small Highlighted warning message.
+     * @param message - The message to log.
+     * @param optionalParams - The optional parameters to log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.smallWarn('A small warning message: {smallWarnMessage}', smallWarnMessage);
+     * ```
+     */
+    static smallWarn(message, ...optionalParams) {
+        this.warn(this.h_small +
+            '\n  ' + this.asfel(message, 2), ...this.asfesop(optionalParams, 2), '\n' + this.warnStyle + this.h_small);
+    }
+    static S_warn = DyFM_Log.smallWarn;
+    /**
+     * Highlighted Tests a warning message.
+     * @param message - The message to test.
+     * @param optionalParams - The optional parameters to test.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.testWarn('A test warning message: {testWarnMessage}', testWarnMessage);
+     * ```
+     */
+    static testWarn(message, ...optionalParams) {
+        this.warn('\n' + this.h_test +
+            '\n\n    ' + this.asfel(message, 4), ...this.asfesop(optionalParams, 4), '\n\n' + this.warnStyle + this.h_test + '\n');
+    }
+    static T_warn = DyFM_Log.testWarn;
+    /**
+     * Logs a highlighted warning message.
+     * @param message - The message to highlight.
+     * @param optionalParams - The optional parameters to highlight.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.highlightedWarn('A highlighted warning message: {highlightedWarnMessage}', highlightedWarnMessage);
+     * ```
+     */
+    static highlightedWarn(message, ...optionalParams) {
+        this.warn('\n\n' + this.h_before +
+            '\n ' + this.h_before +
+            '\n  ' + this.h_before +
+            '\n\n    ' + this.asfel(message, 4), ...this.asfesop(optionalParams, 4), '\n\n  ' + this.warnStyle + this.h_after +
+            '\n ' + this.h_after +
+            '\n' + this.h_after + '\n\n');
+    }
+    static H_warn = DyFM_Log.highlightedWarn;
+    /**
+     * Logs a small success message.
+     * @param message - The message to log.
+     * @param optionalParams - The optional parameters to log.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.smallSuccess('A small success message: {smallSuccessMessage}', smallSuccessMessage);
+     * ```
+     */
+    static smallSuccess(message, ...optionalParams) {
+        this.success(this.h_small +
+            '\n  ' + this.asfel(message, 2), ...this.asfesop(optionalParams, 2), '\n' + this.successStyle + this.h_small);
+    }
+    static S_success = DyFM_Log.smallSuccess;
+    /**
+     * Tests a success message.
+     * @param message - The message to test.
+     * @param optionalParams - The optional parameters to test.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.testSuccess('A test success message: {testSuccessMessage}', testSuccessMessage);
+     * ```
+     */
+    static testSuccess(message, ...optionalParams) {
+        this.success('\n' + this.h_test +
+            '\n\n    ' + this.asfel(message, 4), ...this.asfesop(optionalParams, 4), '\n\n' + this.successStyle + this.h_test + '\n');
+    }
+    static T_success = DyFM_Log.testSuccess;
+    /**
+     * Logs a highlighted success message.
+     * @param message - The message to highlight.
+     * @param optionalParams - The optional parameters to highlight.
+     */
+    static highlightedSuccess(message, ...optionalParams) {
+        this.success('\n\n' + this.h_before +
+            '\n ' + this.h_before +
+            '\n  ' + this.h_before +
+            '\n\n    ' + this.asfel(message, 4), ...this.asfesop(optionalParams, 4), '\n\n  ' + this.successStyle + this.h_after +
+            '\n ' + this.h_after +
+            '\n' + this.h_after + '\n\n');
+    }
+    static H_success = DyFM_Log.highlightedSuccess;
+    /**
+     * Removes the log styles from a message.
+     * @param message - The message to remove the styles from.
+     * @returns The message without the styles.
+     */
+    static removeLogStyles(message) {
+        for (const styleKey of DyFM_allLogStyles) {
+            message = message.replaceAll(styleKey, '');
+        }
+        return message;
+    }
+    /**
+     * Silences all logs.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.silenceLogs();
+     * ```
+     */
+    static silenceLogs() {
+        console.log = () => { };
+    }
+    /**
+     * Silences non-error logs.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.silenceNonErrorLogs();
+     * ```
+     */
+    static silenceNonErrorLogs() {
+        console.log = () => { };
+        console.info = () => { };
+        console.warn = () => { };
+    }
+    /**
+     * Silences all logs.
+     *
+     * @example
+     * ```ts
+     * DyFM_Log.silenceConsole();
+     * ```
+     */
+    static silenceConsole() {
+        console.log = () => { };
+        console.info = () => { };
+        console.warn = () => { };
+        console.error = () => { };
+    }
+    /**
+     * Adds breaks and tabs to the string parameters.
+     * @param params - The parameters to add the breaks and tabs to.
+     * @returns The parameters with the breaks and tabs added.
+     *
+     * @example
+     * ```ts
+     * const params = [ 'Hello, world!', 'Hello, world!', 'Hello, world!' ];
+     * const result = DyFM_Log.addBreaksAndTabsToStringParams(params);
+     * console.log(result); // [ 'Hello, world!', 'Hello, world!', 'Hello, world!' ]
+     * ```
+     */
+    static addBreaksAndTabsToStringParams(params) {
+        return params.map((param) => {
+            if (typeof param === 'string') {
+                return '\n    ' + param;
+            }
+            return param;
+        });
+    }
+    /**
+     * Adds spaces for each line.
+     * @param message - The message to add the spaces to.
+     * @param spaces - The number of spaces to add.
+     * @returns The message with the spaces added.
+     *
+     * @example
+     * ```ts
+     * const message = 'Hello, world!\nHello, world!\nHello, world!';
+     * const result = DyFM_Log.addSpacesForEachLine(message, 2);
+     * console.log(result); // Hello, world!  Hello, world!  Hello, world!
+     * ```
+     */
+    static addSpacesForEachLine(message, spaces) {
+        return message.replaceAll('\n', '\n' + ' '.repeat(spaces));
+    }
+    static asfel = this.addSpacesForEachLine;
+    /**
+     * Adds spaces for each string optional parameter.
+     * @param params - The parameters to add the spaces to.
+     * @param spaces - The number of spaces to add.
+     * @returns The parameters with the spaces added.
+     *
+     * @example
+     * ```ts
+     * const params = [ 'Hello, world!', 'Hello, world!', 'Hello, world!' ];
+     * const result = DyFM_Log.addSpacesForEachStringOptionalParam(params, 2);
+     * console.log(result); // [ 'Hello, world!  Hello, world!  Hello, world!' ]
+     * ```
+     */
+    static addSpacesForEachStringOptionalParam(params, spaces) {
+        return params.map((param) => {
+            if (typeof param === 'string') {
+                return this.addSpacesForEachLine(param, spaces);
+            }
+            return param;
+        });
+    }
+    static asfesop = this.addSpacesForEachStringOptionalParam;
+}

package/build-esm/_collections/utils/math/box-bounds.util.js

@@ -0,0 +1,159 @@
+import { DyFM_Vector2_Util } from './vector2.util';
+/**
+ * The main difference between static class functions and instance functions
+ * is that static functions return new BoxBounds,
+ * while instance functions change the current BoxBounds and returns itself.
+ * (if this is not true, report it as a bug)
+ *
+ * @example
+ * ```ts
+ * const boxBounds = new DyFM_BoxBounds_Util({ x: 0, y: 0 }, { x: 10, y: 10 });
+ * boxBounds.pos = { x: 5, y: 5 };
+ * console.log(boxBounds.pos);
+ * ```
+ */
+export class DyFM_BoxBounds_Util {
+    _pos;
+    /**
+     * setting the position will also recalculate the center and centerMargin
+     */
+    set pos(value) {
+        this._pos.newValues(value);
+        this.calcCenter();
+    }
+    /**
+     * getting the position will return the position as a DyFM_Vector2_Util
+     */
+    get pos() {
+        return this._pos;
+    }
+    _size;
+    /**
+     * setting the size will also recalculate the center and centerMargin
+     */
+    set size(value) {
+        this._size.newValues(value);
+        this.calcCenter();
+    }
+    /**
+     * getting the size will return the size as a DyFM_Vector2_Util
+     */
+    get size() {
+        return this._size;
+    }
+    _center;
+    /**
+     * getting the center will return the center as a DyFM_Vector2_Util
+     * (this is calculated from the position and size every time they are set)
+     */
+    get center() {
+        return this._center;
+    }
+    _centerMargin;
+    /**
+     * getting the centerMargin will return the centerMargin as a DyFM_Vector2_Util
+     * (this is calculated from the size every time it is set)
+     */
+    get centerMargin() {
+        return this._centerMargin;
+    }
+    constructor(
+    /** top left corner */
+    position, 
+    /** height and width */
+    size) {
+        this._pos = new DyFM_Vector2_Util(position);
+        this._size = new DyFM_Vector2_Util(size);
+        this.calcCenter();
+    }
+    /**
+     * returns true if the box bounds has been constructed
+     */
+    constructed() {
+        return true;
+    }
+    /**
+     * sets the position and size of the box bounds
+     * (this will also recalculate the center and centerMargin)
+     *
+     * @example
+     * ```ts
+     * const boxBounds = new DyFM_BoxBounds_Util({ x: 0, y: 0 }, { x: 10, y: 10 });
+     * boxBounds.newValues({ x: 5, y: 5 }, { x: 20, y: 20 });
+     * ```
+     */
+    newValues(position, size) {
+        if (position === undefined) {
+            throw new Error('new position is undefined!');
+        }
+        if (size === undefined) {
+            throw new Error('new size is undefined!');
+        }
+        this._pos.newValues(position);
+        this._size.newValues(size);
+        this.calcCenter();
+    }
+    /**
+     * returns true if the position is within the box bounds
+     *
+     * @example
+     * ```ts
+     * const boxBounds = new DyFM_BoxBounds_Util({ x: 0, y: 0 }, { x: 10, y: 10 });
+     * const position = new DyFM_Vector2({ x: 5, y: 5 });
+     * const isWithinBounds = DyFM_BoxBounds_Util.bounds(boxBounds, position);
+     * console.log(isWithinBounds);
+     * ```
+     */
+    static bounds(box, position) {
+        return box.pos.x <= position.x && position.x <= box.pos.x + box.size.x &&
+            box.pos.y <= position.y && position.y <= box.pos.y + box.size.y;
+    }
+    /**
+     * returns true if the position is within the box bounds
+     *
+     * @example
+     * ```ts
+     * const boxBounds = new DyFM_BoxBounds_Util({ x: 0, y: 0 }, { x: 10, y: 10 });
+     * const isWithinBounds = boxBounds.bounds(new DyFM_Vector2({ x: 5, y: 5 });
+     * console.log(isWithinBounds);
+     * ```
+     */
+    bounds(position) {
+        return DyFM_BoxBounds_Util.bounds(this, position);
+    }
+    /**
+     * calculates the center and centerMargin of the box bounds
+     *
+     * only usable inside the class
+     */
+    calcCenter() {
+        const halfSize = DyFM_Vector2_Util.divide(this.size, 2);
+        this._center = DyFM_Vector2_Util.plus(this.pos, halfSize);
+        this._centerMargin = DyFM_Vector2_Util.negative(halfSize);
+    }
+    /**
+     * returns the box bounds as a DyFM_BoxBounds
+     */
+    get() {
+        return {
+            pos: this._pos.get(),
+            size: this._size.get(),
+            center: this._center.get(),
+            centerMargin: this._centerMargin.get()
+        };
+    }
+    getBoxBounds = this.get;
+    toBoxBounds = this.get;
+    /**
+     * returns a new DyFM_BoxBounds_Util with the same position and size
+     *
+     * @example
+     * ```ts
+     * const boxBounds = new DyFM_BoxBounds_Util({ x: 0, y: 0 }, { x: 10, y: 10 });
+     * const clonedBoxBounds = boxBounds.clone();
+     * ```
+     */
+    clone() {
+        return new DyFM_BoxBounds_Util(this._pos.clone(), this._size.clone());
+    }
+}