@rb-games/core 0.1.0

package/dist/utils/index.js

@@ -0,0 +1,899 @@
+import { cloneDeep, merge, set, get } from 'lodash';
+import { Rectangle, Color } from 'pixi.js';
+
+// utils/Logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["ERROR"] = 0] = "ERROR";
+  LogLevel2[LogLevel2["WARN"] = 1] = "WARN";
+  LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 3] = "DEBUG";
+  LogLevel2[LogLevel2["TRACE"] = 4] = "TRACE";
+  return LogLevel2;
+})(LogLevel || {});
+var Logger = class _Logger {
+  static instance;
+  config;
+  // Terminal colors (for Node.js environment)
+  terminalColors = {
+    reset: "\x1B[0m",
+    red: "\x1B[31m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    green: "\x1B[32m",
+    gray: "\x1B[90m",
+    cyan: "\x1B[36m",
+    magenta: "\x1B[35m",
+    white: "\x1B[37m"
+  };
+  // Browser console colors (using CSS)
+  browserColors = {
+    timestamp: "color: gray",
+    context: "color: cyan; font-weight: bold",
+    message: "color: white",
+    error: "color: red; font-weight: bold",
+    warn: "color: orange; font-weight: bold",
+    info: "color: dodgerblue; font-weight: bold",
+    debug: "color: green",
+    trace: "color: gray"
+  };
+  levelLabels = {
+    [0 /* ERROR */]: "ERROR",
+    [1 /* WARN */]: "WARN",
+    [2 /* INFO */]: "INFO",
+    [3 /* DEBUG */]: "DEBUG",
+    [4 /* TRACE */]: "TRACE"
+  };
+  levelColors = {
+    [0 /* ERROR */]: this.terminalColors.red,
+    [1 /* WARN */]: this.terminalColors.yellow,
+    [2 /* INFO */]: this.terminalColors.blue,
+    [3 /* DEBUG */]: this.terminalColors.green,
+    [4 /* TRACE */]: this.terminalColors.gray
+  };
+  levelBrowserColors = {
+    [0 /* ERROR */]: this.browserColors.error,
+    [1 /* WARN */]: this.browserColors.warn,
+    [2 /* INFO */]: this.browserColors.info,
+    [3 /* DEBUG */]: this.browserColors.debug,
+    [4 /* TRACE */]: this.browserColors.trace
+  };
+  /**
+   * Private constructor for singleton pattern
+   */
+  constructor() {
+    var _a;
+    this.config = {
+      level: 3 /* DEBUG */,
+      // Default log level
+      enabled: true,
+      // Logging enabled by default
+      showTimestamp: false,
+      // Show timestamps by default
+      showColors: true
+      // Show colors by default
+    };
+    if ((_a = import.meta.env) == null ? void 0 : _a.DEV) {
+      console.warn(
+        "[Logger] For better debugging experience, add Logger.ts to DevTools ignore list:\nDevTools \u2192 Settings (F1) \u2192 Ignore List \u2192 Add pattern: /Logger\\.ts$"
+      );
+    }
+  }
+  /**
+   * Get the singleton instance of the Logger
+   */
+  static getInstance() {
+    if (!_Logger.instance) {
+      _Logger.instance = new _Logger();
+    }
+    return _Logger.instance;
+  }
+  /**
+   * Configure the logger
+   * @param config Configuration options
+   */
+  configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Enable or disable logging
+   * @param enabled Whether logging is enabled
+   */
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+  }
+  /**
+   * Set the log level
+   * @param level The log level to set
+   */
+  setLevel(level) {
+    this.config.level = level;
+  }
+  /**
+   * Get the current log level
+   */
+  getLevel() {
+    return this.config.level;
+  }
+  /**
+   * Log an error message
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  error(message, ...args) {
+    this.log(0 /* ERROR */, message, ...args);
+  }
+  /**
+   * Log a warning message
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  warn(message, ...args) {
+    this.log(1 /* WARN */, message, ...args);
+  }
+  /**
+   * Log an info message
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  info(message, ...args) {
+    this.log(2 /* INFO */, message, ...args);
+  }
+  /**
+   * Log a debug message
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  debug(message, ...args) {
+    this.log(3 /* DEBUG */, message, ...args);
+  }
+  /**
+   * Log a trace message
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  trace(message, ...args) {
+    this.log(4 /* TRACE */, message, ...args);
+  }
+  /**
+   * Log a message with a specific log level
+   * @param level The log level
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  log(level, message, ...args) {
+    if (!this.config.enabled || level > this.config.level) {
+      return;
+    }
+    if (!this.shouldLogMessage(message)) {
+      return;
+    }
+    const isBrowser = typeof window !== "undefined";
+    if (isBrowser && this.config.showColors) {
+      this.logBrowser(level, message, ...args);
+    } else {
+      this.logTerminal(level, message, ...args);
+    }
+  }
+  extractContext(message) {
+    const contextMatch = message.match(/^\[([^\]]+)\]\s(.*)$/);
+    if (!contextMatch) {
+      return {
+        context: "",
+        messageContent: message
+      };
+    }
+    return {
+      context: contextMatch[1],
+      messageContent: contextMatch[2]
+    };
+  }
+  matchesFilter(value, matchers) {
+    if (!(matchers == null ? void 0 : matchers.length)) {
+      return false;
+    }
+    return matchers.some((matcher) => {
+      if (typeof matcher === "string") {
+        return value.includes(matcher);
+      }
+      matcher.lastIndex = 0;
+      return matcher.test(value);
+    });
+  }
+  shouldLogMessage(message) {
+    var _a, _b;
+    const filter = this.config.filter;
+    if (!filter) {
+      return true;
+    }
+    const hasFilters = Boolean(((_a = filter.contexts) == null ? void 0 : _a.length) || ((_b = filter.messages) == null ? void 0 : _b.length));
+    if (!hasFilters) {
+      return true;
+    }
+    const { context, messageContent } = this.extractContext(message);
+    const contextMatches = this.matchesFilter(context, filter.contexts);
+    const messageMatches = this.matchesFilter(messageContent, filter.messages);
+    const matches = contextMatches || messageMatches;
+    return filter.mode === "exclude" ? !matches : matches;
+  }
+  /**
+   * Log a message in terminal/node environment
+   */
+  logTerminal(level, message, ...args) {
+    let timestamp = "";
+    let levelStr = "";
+    let contextPart = "";
+    const contextMatch = message.match(/^\[([^\]]+)\]\s(.*)$/);
+    let messageContent = message;
+    if (contextMatch) {
+      contextPart = `[${contextMatch[1]}] `;
+      messageContent = contextMatch[2];
+    }
+    if (this.config.showTimestamp) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      timestamp = `[${now}] `;
+    }
+    levelStr = `[${this.levelLabels[level]}] `;
+    if (this.config.showColors) {
+      const levelColor = this.levelColors[level];
+      const contextColor = this.terminalColors.cyan;
+      const timestampColor = this.terminalColors.gray;
+      const messageColor = this.terminalColors.white;
+      timestamp = `${timestampColor}${timestamp}${this.terminalColors.reset}`;
+      levelStr = `${levelColor}${levelStr}${this.terminalColors.reset}`;
+      if (contextPart) {
+        contextPart = `${contextColor}${contextPart}${this.terminalColors.reset}`;
+      }
+      messageContent = `${messageColor}${messageContent}${this.terminalColors.reset}`;
+    }
+    const formattedMessage = timestamp + levelStr + contextPart + messageContent;
+    switch (level) {
+      case 0 /* ERROR */:
+        console.error(formattedMessage, ...args);
+        break;
+      case 1 /* WARN */:
+        console.warn(formattedMessage, ...args);
+        break;
+      case 2 /* INFO */:
+        console.info(formattedMessage, ...args);
+        break;
+      case 3 /* DEBUG */:
+      case 4 /* TRACE */:
+      default:
+        console.log(formattedMessage, ...args);
+        break;
+    }
+  }
+  /**
+   * Log a message in browser environment with CSS styling
+   */
+  logBrowser(level, message, ...args) {
+    const contextMatch = message.match(/^\[([^\]]+)\]\s(.*)$/);
+    let context = "";
+    let messageContent = message;
+    if (contextMatch) {
+      context = contextMatch[1];
+      messageContent = contextMatch[2];
+    }
+    let format = "";
+    const formatArgs = [];
+    if (this.config.showTimestamp) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      format += "%c[" + now + "] ";
+      formatArgs.push(this.browserColors.timestamp);
+    }
+    format += "%c[" + this.levelLabels[level] + "] ";
+    formatArgs.push(this.levelBrowserColors[level]);
+    if (context) {
+      format += "%c[" + context + "] ";
+      formatArgs.push(this.browserColors.context);
+    }
+    format += "%c" + messageContent;
+    formatArgs.push(this.browserColors.message);
+    switch (level) {
+      case 0 /* ERROR */:
+        console.error(format, ...formatArgs, ...args);
+        break;
+      case 1 /* WARN */:
+        console.warn(format, ...formatArgs, ...args);
+        break;
+      case 2 /* INFO */:
+        console.info(format, ...formatArgs, ...args);
+        break;
+      case 3 /* DEBUG */:
+      case 4 /* TRACE */:
+      default:
+        console.log(format, ...formatArgs, ...args);
+        break;
+    }
+  }
+  /**
+   * Creates a context-specific logger.
+   *
+   * Context loggers automatically prefix all log messages with a context tag.
+   * Commonly used in plugins and classes to identify log sources.
+   *
+   * @param context - Context name (e.g., 'MyPlugin', 'SceneManager')
+   * @returns ContextLogger instance
+   *
+   * @example
+   * ```typescript
+   * class DisplayPlugin {
+   *   private logger = logger.createContextLogger('DisplayPlugin');
+   *
+   *   initialize() {
+   *     this.logger.info('Initializing display');
+   *     // Output: [INFO] [DisplayPlugin] Initializing display
+   *   }
+   * }
+   * ```
+   */
+  createContextLogger(context) {
+    return new ContextLogger(this, context);
+  }
+};
+var ContextLogger = class {
+  logger;
+  context;
+  constructor(logger2, context) {
+    this.logger = logger2;
+    this.context = context;
+  }
+  /**
+   * Log an error message
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  error(message, ...args) {
+    this.logger.error(`[${this.context}] ${message}`, ...args);
+  }
+  /**
+   * Log a warning message
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  warn(message, ...args) {
+    this.logger.warn(`[${this.context}] ${message}`, ...args);
+  }
+  /**
+   * Log an info message
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  info(message, ...args) {
+    this.logger.info(`[${this.context}] ${message}`, ...args);
+  }
+  /**
+   * Log a debug message
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  debug(message, ...args) {
+    this.logger.debug(`[${this.context}] ${message}`, ...args);
+  }
+  /**
+   * Log a trace message
+   * @param message The message to log
+   * @param args Additional arguments to log
+   */
+  trace(message, ...args) {
+    this.logger.trace(`[${this.context}] ${message}`, ...args);
+  }
+};
+var logger = Logger.getInstance();
+var contextLoggers = /* @__PURE__ */ new Map();
+function getLogger(context) {
+  let cached = contextLoggers.get(context);
+  if (!cached) {
+    cached = new ContextLogger(logger, context);
+    contextLoggers.set(context, cached);
+  }
+  return cached;
+}
+function DataInjector(obj, path, data, replace = false) {
+  const result = cloneDeep(obj);
+  if (path === "" || path === void 0 || path === null) {
+    return merge({}, result, cloneDeep(data));
+  }
+  if (replace) {
+    set(result, path, cloneDeep(data));
+    return result;
+  }
+  const current = get(result, path);
+  const merged = merge({}, current ?? {}, data);
+  set(result, path, merged);
+  return result;
+}
+function adjustColor(color, amount, sign) {
+  const colorObj = new Color(color);
+  const rgb = {
+    r: colorObj.red * 255,
+    g: colorObj.green * 255,
+    b: colorObj.blue * 255
+  };
+  const delta = 255 * amount * sign;
+  const newR = Math.max(0, Math.min(255, rgb.r + delta));
+  const newG = Math.max(0, Math.min(255, rgb.g + delta));
+  const newB = Math.max(0, Math.min(255, rgb.b + delta));
+  return new Color([newR / 255, newG / 255, newB / 255]);
+}
+function lightenColor(color, amount) {
+  return adjustColor(color, amount, 1);
+}
+function darkenColor(color, amount) {
+  return adjustColor(color, amount, -1);
+}
+
+// utils/NumberFormatter.ts
+var DEFAULT_CONFIG = {
+  mask: "#,##0.##",
+  denom: 1,
+  expressThreshold: 1e3,
+  expressUnits: ["K", "M", "B", "T", "Q"],
+  decimalPrecision: 2,
+  roundedSymbol: "+"
+};
+var NumberFormatter = class _NumberFormatter {
+  static instance;
+  config;
+  maskCache = /* @__PURE__ */ new Map();
+  /**
+   * Private constructor for singleton pattern
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Configure the NumberFormatter singleton.
+   *
+   * @param config - Configuration options
+   * @returns NumberFormatter instance
+   */
+  static configure(config) {
+    const finalConfig = { ...DEFAULT_CONFIG, ...config };
+    if (!_NumberFormatter.instance) {
+      _NumberFormatter.instance = new _NumberFormatter(finalConfig);
+    } else {
+      _NumberFormatter.instance.config = finalConfig;
+      _NumberFormatter.instance.maskCache.clear();
+    }
+    return _NumberFormatter.instance;
+  }
+  /**
+   * Get the singleton instance.
+   *
+   * If not configured yet, initializes with default configuration.
+   *
+   * @returns NumberFormatter instance
+   */
+  static getInstance() {
+    if (!_NumberFormatter.instance) {
+      _NumberFormatter.instance = new _NumberFormatter(DEFAULT_CONFIG);
+    }
+    return _NumberFormatter.instance;
+  }
+  /**
+   * Format a number using the configured mask.
+   *
+   * @param value - Number to format
+   * @param options - Optional formatting options
+   * @returns Formatted string
+   *
+   * @example
+   * ```typescript
+   * formatter.format(1500); // "$ 15.00"
+   * formatter.format(1500, { forceDecimals: true }); // "$ 15.00"
+   * formatter.format(1500, { ignoreDenom: true }); // "$ 1,500.00"
+   * ```
+   */
+  format(value, options = {}) {
+    const { prefix = "", forceDecimals = false, ignoreDenom = false } = options;
+    const actualValue = ignoreDenom ? value : value * this.config.denom;
+    let mask = this.config.mask;
+    if (forceDecimals) {
+      mask = mask.replace(/\.##/g, ".00");
+    }
+    return this.applyMask(mask, actualValue) + prefix;
+  }
+  /**
+   * Format a number in express mode (shortened with K/M/B/T).
+   *
+   * @param value - Number to format
+   * @param options - Optional formatting options
+   * @returns Formatted string with unit suffix
+   *
+   * @example
+   * ```typescript
+   * formatter.express(150000); // "$ 1.5K"
+   * formatter.express(2500000); // "$ 2.5M"
+   * formatter.express(500, { threshold: 100 }); // "$ 0.5K"
+   * ```
+   */
+  express(value, options = {}) {
+    const {
+      prefix = "",
+      forceDecimals = false,
+      ignoreDenom = false,
+      threshold = this.config.expressThreshold
+    } = options;
+    const actualValue = ignoreDenom ? value : value * this.config.denom;
+    if (actualValue < threshold) {
+      return this.format(value, { prefix, forceDecimals, ignoreDenom });
+    }
+    let unitIndex = -1;
+    let shortenedNum = actualValue;
+    while (shortenedNum >= 1e3 && unitIndex < this.config.expressUnits.length - 1) {
+      shortenedNum /= 1e3;
+      unitIndex++;
+    }
+    const factor = Math.pow(10, this.config.decimalPrecision);
+    const roundedNum = Math.floor(shortenedNum * factor) / factor;
+    const isRounded = roundedNum < shortenedNum;
+    let mask = this.config.mask;
+    if (forceDecimals) {
+      mask = mask.replace(/\.##/g, ".00");
+    }
+    const parsed = this.parseMask(mask);
+    const formattedNumber = this.applyMask(parsed.pattern, roundedNum) + (this.config.expressUnits[unitIndex] || "") + (isRounded ? this.config.roundedSymbol : "");
+    return parsed.prefix + formattedNumber + parsed.suffix + prefix;
+  }
+  /**
+   * Parse a mask string into its components.
+   *
+   * @param mask - Mask string to parse
+   * @returns Parsed mask information
+   * @internal
+   */
+  parseMask(mask) {
+    if (this.maskCache.has(mask)) {
+      return this.maskCache.get(mask);
+    }
+    const len = mask.length;
+    const start = mask.search(/[0-9\-\+#]/);
+    const prefix = start > 0 ? mask.substring(0, start).trim() : "";
+    const str = mask.split("").reverse().join("");
+    const end = str.search(/[0-9\-\+#]/);
+    const offset = len - end;
+    const indx = offset + (mask.substring(offset, offset + 1) === "." ? 1 : 0);
+    const suffix = end > 0 ? mask.substring(indx, len).trim() : "";
+    const pattern = mask.substring(start, indx);
+    const result = pattern.match(/[^\d\-\+#]/g);
+    const decimal = result && result[result.length - 1] || ".";
+    const group = result && result[1] && result[0] || ",";
+    const parts = pattern.split(decimal);
+    const decimalPlaces = parts[1] ? parts[1].length : 0;
+    const szSep = parts[0].split(group);
+    const groupSize = szSep[1] ? szSep[szSep.length - 1].length : 0;
+    const cleanPattern = parts[0].replace(new RegExp(`\\${group}`, "g"), "");
+    const posLeadZero = cleanPattern.indexOf("0");
+    const parsed = {
+      pattern,
+      prefix,
+      suffix,
+      decimal,
+      group,
+      decimalPlaces,
+      posLeadZero,
+      groupSize
+    };
+    this.maskCache.set(mask, parsed);
+    return parsed;
+  }
+  /**
+   * Apply a mask to a number value.
+   *
+   * @param mask - Mask pattern
+   * @param value - Number to format
+   * @returns Formatted string
+   * @internal
+   */
+  applyMask(mask, value) {
+    if (!mask || isNaN(+value) || value === "") return value;
+    const parsed = this.parseMask(mask);
+    let isNegative = value < 0;
+    value = Math.abs(value);
+    const maskParts = parsed.pattern.split(parsed.decimal);
+    value = value.toFixed(maskParts[1] ? maskParts[1].length : 0);
+    value = +value + "";
+    const posTrailZero = maskParts[1] ? maskParts[1].lastIndexOf("0") : -1;
+    let parts = value.split(".");
+    if (!parts[1] || parts[1] && parts[1].length <= posTrailZero) {
+      value = (+value).toFixed(posTrailZero + 1);
+    }
+    const szSep = maskParts[0].split(parsed.group);
+    const cleanMask = szSep.join("");
+    if (parsed.posLeadZero > -1) {
+      while (parts[0].length < cleanMask.length - parsed.posLeadZero) {
+        parts[0] = "0" + parts[0];
+      }
+    } else if (+parts[0] === 0) {
+      parts[0] = "";
+    }
+    const valueParts = value.split(".");
+    valueParts[0] = parts[0];
+    if (parsed.groupSize) {
+      const integer = valueParts[0];
+      let str = "";
+      const offset = integer.length % parsed.groupSize;
+      const len = integer.length;
+      for (let i = 0; i < len; i++) {
+        str += integer.charAt(i);
+        if (!((i - offset + 1) % parsed.groupSize) && i < len - parsed.groupSize) {
+          str += parsed.group;
+        }
+      }
+      valueParts[0] = str;
+    }
+    valueParts[1] = maskParts[1] && valueParts[1] ? parsed.decimal + valueParts[1] : "";
+    const result = valueParts.join("");
+    if (result === "0" || result === "") {
+      isNegative = false;
+    }
+    return parsed.prefix + (isNegative ? "-" : "") + result + parsed.suffix;
+  }
+  /**
+   * Decimal/group separators and fraction length from the configured mask.
+   * Use for free-form numeric inputs (e.g. bet multipliers) that are not currency amounts.
+   */
+  getMaskLocale() {
+    const parsed = this.parseMask(this.config.mask);
+    return {
+      decimal: parsed.decimal,
+      group: parsed.group,
+      decimalPlaces: parsed.decimalPlaces > 0 ? parsed.decimalPlaces : this.config.decimalPrecision
+    };
+  }
+  /**
+   * Format a number using only the numeric portion of the mask (no prefix/suffix, no denom).
+   * Suitable for multipliers and limits (e.g. autoplay 10.5× bet).
+   */
+  formatPlainNumber(value, options = {}) {
+    const { forceDecimals = false } = options;
+    const parsed = this.parseMask(this.config.mask);
+    let pattern = parsed.pattern;
+    if (forceDecimals) {
+      pattern = pattern.replace(/\.##/g, ".00");
+    }
+    return this.applyMask(pattern, value);
+  }
+  /**
+   * Get current configuration.
+   *
+   * @returns Current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// utils/ArrayUtils.ts
+Object.defineProperty(Array.prototype, "exclude", {
+  value: function(...indexToExclude) {
+    return this.filter((_, index) => !indexToExclude.includes(index));
+  },
+  enumerable: false
+});
+Object.defineProperty(Array.prototype, "random", {
+  value: function() {
+    const randomIndex = Math.floor(Math.random() * this.length);
+    return this[randomIndex];
+  },
+  enumerable: false
+});
+Object.defineProperty(Array.prototype, "lastItem", {
+  value: function() {
+    return this[this.length - 1];
+  },
+  enumerable: false
+});
+Object.defineProperty(Array.prototype, "firstItem", {
+  value: function() {
+    return this[0];
+  },
+  enumerable: false
+});
+Object.defineProperty(Array.prototype, "clone", {
+  value: function() {
+    return [...this];
+  },
+  enumerable: false
+});
+Object.defineProperty(Array.prototype, "shuffle", {
+  value: function() {
+    const array = [...this];
+    for (let i = array.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array;
+  },
+  enumerable: false
+});
+var __arrayUtilsLoaded = true;
+
+// utils/ObjectUtils.ts
+function getNestedValue(obj, path) {
+  return path.split(".").reduce((current, key) => current == null ? void 0 : current[key], obj);
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  const lastKey = keys.pop();
+  const target = keys.reduce((current, key) => {
+    if (current[key] === void 0 || current[key] === null) {
+      current[key] = {};
+    }
+    return current[key];
+  }, obj);
+  target[lastKey] = value;
+}
+function hasNestedProperty(obj, path) {
+  return getNestedValue(obj, path) !== void 0;
+}
+function deepClone(obj) {
+  return structuredClone(obj);
+}
+function calculateAnimationSpeed(exportedFps = 12, speed = 1) {
+  return exportedFps / 60 * speed;
+}
+function applyAnchor(element, anchor, defaultAnchor) {
+  if (!("anchor" in element)) return;
+  const elementWithAnchor = element;
+  if (anchor) {
+    elementWithAnchor.anchor.set(anchor.x, anchor.y);
+  } else if (defaultAnchor) {
+    elementWithAnchor.anchor.set(defaultAnchor.x, defaultAnchor.y);
+  }
+}
+function applyScale(element, scale) {
+  if (scale === void 0) return;
+  if (typeof scale === "number") {
+    element.scale.set(scale);
+  } else {
+    element.scale.set(scale.x, scale.y);
+  }
+}
+function applyCommonProperties(element, config) {
+  if (config.alpha !== void 0) {
+    element.alpha = config.alpha;
+  }
+  if (config.blendMode) {
+    element.blendMode = config.blendMode;
+  }
+  applyScale(element, config.scale);
+}
+function updateBounds(existingBounds, x, y, width, height) {
+  if (existingBounds instanceof Rectangle) {
+    existingBounds.x = x;
+    existingBounds.y = y;
+    existingBounds.width = width;
+    existingBounds.height = height;
+    return existingBounds;
+  }
+  return new Rectangle(x, y, width, height);
+}
+
+// utils/Throttle.ts
+function debounce(func, wait = 0, options = {}) {
+  let lastArgs;
+  let lastThis;
+  const maxWait = options.maxWait ? options.maxWait : wait;
+  let result;
+  let timerId;
+  let lastCallTime;
+  let lastInvokeTime = 0;
+  const leading = !!options.leading;
+  const maxing = "maxWait" in options;
+  const trailing = options.trailing ?? true;
+  const useRAF = wait !== 0 && typeof globalThis.requestAnimationFrame === "function";
+  if (typeof func !== "function") {
+    throw new TypeError("Expected a function");
+  }
+  function invokeFunc(time) {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function startTimer(pendingFunc, milliseconds) {
+    if (useRAF) {
+      if (typeof timerId === "number") {
+        globalThis.cancelAnimationFrame(timerId);
+      }
+      return globalThis.requestAnimationFrame(pendingFunc);
+    }
+    return setTimeout(pendingFunc, milliseconds);
+  }
+  function cancelTimer(id) {
+    if (useRAF) {
+      globalThis.cancelAnimationFrame(id);
+      return;
+    }
+    clearTimeout(id);
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = startTimer(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    const timeSinceLastCall = time - (lastCallTime || 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    const timeWaiting = wait - timeSinceLastCall;
+    return maxing ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    const timeSinceLastCall = time - (lastCallTime || 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = startTimer(timerExpired, remainingWait(time));
+    return void 0;
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      cancelTimer(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(Date.now());
+  }
+  function pending() {
+    return timerId !== void 0;
+  }
+  function debounced(...args) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = args;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        timerId = startTimer(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = startTimer(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  debounced.pending = pending;
+  return debounced;
+}
+function throttle(func, wait, options = {}) {
+  const leading = options.leading ?? true;
+  const trailing = options.trailing ?? true;
+  if (typeof func !== "function") {
+    throw new TypeError("Expected a function");
+  }
+  return debounce(func, wait, {
+    leading,
+    trailing,
+    maxWait: wait
+  });
+}
+
+export { ContextLogger, DataInjector, LogLevel, Logger, NumberFormatter, __arrayUtilsLoaded, applyAnchor, applyCommonProperties, applyScale, calculateAnimationSpeed, darkenColor, debounce, deepClone, getLogger, getNestedValue, hasNestedProperty, lightenColor, logger, setNestedValue, throttle, updateBounds };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map