@mlightcad/common 1.4.13 → 1.4.15

package/dist/common.js

@@ -4,17 +4,14 @@ function W(r, e) {
     if (typeof s != "string" && !Array.isArray(s)) {
       for (const o in s)
         if (o !== "default" && !(o in r)) {
-          const n = Object.getOwnPropertyDescriptor(s, o);
-          n && Object.defineProperty(r, o, n.get ? n : {
-            enumerable: !0,
-            get: () => s[o]
-          });
+          const i = Object.getOwnPropertyDescriptor(s, o);
+          i && Object.defineProperty(r, o, i.get ? i : { enumerable: !0, get: () => s[o] });
         }
     }
   }
   return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
 }
-var i = /* @__PURE__ */ ((r) => (r[r.ByColor = 1] = "ByColor", r[r.ByACI = 2] = "ByACI", r[r.ByLayer = 3] = "ByLayer", r[r.ByBlock = 4] = "ByBlock", r[r.None = 0] = "None", r))(i || {});
+var n = /* @__PURE__ */ ((r) => (r[r.ByColor = 1] = "ByColor", r[r.ByACI = 2] = "ByACI", r[r.ByLayer = 3] = "ByLayer", r[r.ByBlock = 4] = "ByBlock", r[r.None = 0] = "None", r))(n || {});
 const G = {
   aliceblue: 15792383,
   antiquewhite: 16444375,
@@ -419,607 +416,286 @@ const G = {
   16777215,
   0
 ];
-class w {
-  /**
-   * Returns the RGB color value for a given AutoCAD color index.
-   *
-   * @param {number} index - The AutoCAD color index value (0-255).
-   * @returns {number} The RGB color value as a 24-bit integer.
-   *
-   * @example
-   * ```typescript
-   * // Get the RGB value for color index 1 (red)
-   * const redColor = AcCmColorUtil.getAcadColor(1); // returns 16711680 (0xFF0000)
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Get special inheritance colors
-   * const byBlock = AcCmColorUtil.getAcadColor(0);   // "ByBlock" color
-   * const byLayer = AcCmColorUtil.getAcadColor(256); // "ByLayer" color
-   * ```
-   */
+class b {
   static getColorByIndex(e) {
     return R[e];
   }
-  /**
-   * Finds the AutoCAD color index associated with a given RGB value.
-   *
-   * @private
-   * @param {number} color - The RGB value to find an index for.
-   * @returns {number | undefined} The color index if found, undefined otherwise.
-   */
   static getIndexByColor(e) {
     const t = R.length - 1;
     for (let s = 1; s < t; ++s)
       if (R[s] === e)
         return s;
   }
-  /**
-   * Returns the RGB color value for a given CSS color name.
-   *
-   * @param {string} name - The CSS color name (e.g., "red", "blue", "aliceblue").
-   * @returns {number | undefined} The RGB color value as a 24-bit integer, or undefined if the name is not found.
-   *
-   * @example
-   * ```typescript
-   * // Get the RGB value for a standard color name
-   * const redColor = AcCmColorUtil.getColorByName("red"); // returns 16711680 (0xFF0000)
-   * const blueColor = AcCmColorUtil.getColorByName("blue"); // returns 255 (0x0000FF)
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Handle undefined for unknown color names
-   * const unknownColor = AcCmColorUtil.getColorByName("unknown"); // returns undefined
-   * ```
-   */
   static getColorByName(e) {
     return G[e.toLowerCase()];
   }
-  /**
-   * Finds the color name associated with a given RGB value.
-   *
-   * @param {number} rgb - The RGB value to find a name for.
-   * @returns {string | undefined} The color name if found, undefined otherwise.
-   */
   static getNameByColor(e) {
     for (const [t, s] of Object.entries(G))
       if (s === e)
         return t;
   }
-  /**
-   * Finds the color name associated with a given color index.
-   *
-   * @param {number} index - The color index to find a name for.
-   * @returns {string | undefined} The color name if found, undefined otherwise.
-   */
   static getNameByIndex(e) {
     const t = this.getColorByIndex(e);
     return this.getNameByColor(t);
   }
 }
-class _ {
-  /**
-   * Constructs a new AcCmColor.
-   * @param method Initial color method (defaults to `ByColor`)
-   * @param value Internal packed value
-   */
-  constructor(e = i.ByLayer, t) {
-    this._colorMethod = e, this._colorMethod == i.ByColor && t == null ? this._value = 16777215 : this._colorMethod == i.ByACI ? t == null ? this._value = 8 : t === 0 ? this._colorMethod = i.ByBlock : t === 256 ? this._colorMethod = i.ByLayer : this._value = Math.max(0, Math.min(t, 256)) : this._value = t;
-  }
-  // ---------------------------------------------------------------------
-  // Color method
-  // ---------------------------------------------------------------------
-  /** Gets the current color method. */
+class B {
+  constructor(e = n.ByLayer, t) {
+    this._colorMethod = e, this._colorMethod == n.ByColor && t == null ? this._value = 16777215 : this._colorMethod == n.ByACI ? t == null ? this._value = 8 : t === 0 ? this._colorMethod = n.ByBlock : t === 256 ? this._colorMethod = n.ByLayer : this._value = Math.max(0, Math.min(t, 256)) : this._value = t;
+  }
   get colorMethod() {
     return this._colorMethod;
   }
-  /**
-   * Sets the color method.
-   *
-   * Note: Changing the method does not modify `_value`.
-   */
   set colorMethod(e) {
     this._colorMethod = e;
   }
-  // ---------------------------------------------------------------------
-  // RGB accessors (ByColor)
-  // ---------------------------------------------------------------------
-  /** Gets the red component (0–255). */
   get red() {
     const e = this.RGB;
     return e != null ? e >> 16 & 255 : void 0;
   }
-  /** Gets the green component (0–255). */
   get green() {
     const e = this.RGB;
     return e != null ? e >> 8 & 255 : void 0;
   }
-  /** Gets the blue component (0–255). */
   get blue() {
     const e = this.RGB;
     return e != null ? e & 255 : void 0;
   }
-  /**
-   * Gets the packed RGB value (0xRRGGBB).
-   *
-   * - For `ByColor`, returns `_value` directly
-   * - For `ByACI`, converts index to RGB via `AcCmColorUtil`
-   * - For `ByLayer` or `ByBlock`, returns `_value` directly
-   */
   get RGB() {
     switch (this._colorMethod) {
-      case i.ByColor:
-      case i.ByBlock:
-      case i.ByLayer:
+      case n.ByColor:
+      case n.ByBlock:
+      case n.ByLayer:
         return this._value;
-      case i.ByACI:
-        return this._value ? w.getColorByIndex(this._value) : this._value;
+      case n.ByACI:
+        return this._value ? b.getColorByIndex(this._value) : this._value;
       default:
         return;
     }
   }
-  /**
-   * Sets the RGB color.
-   *
-   * @param r Red component (0–255)
-   * @param g Green component (0–255)
-   * @param b Blue component (0–255)
-   * @returns The current instance for chaining
-   */
   setRGB(e, t, s) {
-    const o = Math.max(0, Math.min(255, Math.round(e))), n = Math.max(0, Math.min(255, Math.round(t))), l = Math.max(0, Math.min(255, Math.round(s)));
-    return this._value = o << 16 | n << 8 | l, this._colorMethod = i.ByColor, this;
-  }
-  /**
-   * Sets the RGB color by a single packed number (0xRRGGBB).
-   *
-   * @param value Packed RGB number
-   */
+    const o = Math.max(0, Math.min(255, Math.round(e))), i = Math.max(0, Math.min(255, Math.round(t))), l = Math.max(0, Math.min(255, Math.round(s)));
+    return this._value = o << 16 | i << 8 | l, this._colorMethod = n.ByColor, this;
+  }
   setRGBValue(e) {
-    return e == null || !Number.isFinite(e) ? (console.warn("Invalid RGB value:", e), this) : (this._value = e & 16777215, this._colorMethod = i.ByColor, this);
-  }
-  /**
-   * Sets the RGB color from a CSS color string.
-   *
-   * Examples:
-   * - "#FF00FF"
-   * - "#F0F"
-   * - "rgb(255,0,255)"
-   * - "rgba(255,0,255,0.5)"
-   * - "red" (named colors)
-   *
-   * @param cssString CSS color string
-   * @returns The current instance for chaining
-   */
+    return e == null || !Number.isFinite(e) ? this : (this._value = e & 16777215, this._colorMethod = n.ByColor, this);
+  }
   setRGBFromCss(e) {
     if (!e) return this;
     const t = e.trim().toLowerCase();
     if (t.startsWith("#")) {
-      let n = 0, l = 0, c = 0;
+      let i = 0, l = 0, c = 0;
       if (t.length === 7)
-        n = parseInt(t.substr(1, 2), 16), l = parseInt(t.substr(3, 2), 16), c = parseInt(t.substr(5, 2), 16);
+        i = parseInt(t.substr(1, 2), 16), l = parseInt(t.substr(3, 2), 16), c = parseInt(t.substr(5, 2), 16);
       else if (t.length === 4)
-        n = parseInt(t[1] + t[1], 16), l = parseInt(t[2] + t[2], 16), c = parseInt(t[3] + t[3], 16);
+        i = parseInt(t[1] + t[1], 16), l = parseInt(t[2] + t[2], 16), c = parseInt(t[3] + t[3], 16);
       else
-        return console.warn("Invalid hex color:", e), this;
-      return this.setRGB(n, l, c);
+        return this;
+      return this.setRGB(i, l, c);
     }
     const s = t.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
     if (s) {
-      const n = parseInt(s[1], 10), l = parseInt(s[2], 10), c = parseInt(s[3], 10);
-      return this.setRGB(n, l, c);
+      const i = parseInt(s[1], 10), l = parseInt(s[2], 10), c = parseInt(s[3], 10);
+      return this.setRGB(i, l, c);
     }
-    const o = w.getColorByName(e);
-    return o !== void 0 ? this.setRGBValue(o) : (console.warn("Unknown CSS color string:", e), this);
-  }
-  /**
-   * Sets the color as a scalar grayscale value.
-   *
-   * @param scalar Scalar value (0–255)
-   * @returns The current instance for chaining
-   */
+    const o = b.getColorByName(e);
+    return o !== void 0 ? this.setRGBValue(o) : this;
+  }
   setScalar(e) {
     return this.setRGB(e, e, e);
   }
-  /**
-   * Gets the hexadecimal representation of the color (e.g., "0xFF00FF").
-   */
   get hexColor() {
     const e = this.RGB;
     return e == null ? void 0 : "0x" + e.toString(16).padStart(6, "0").toUpperCase();
   }
-  /**
-   * Gets the CSS RGB color string (e.g., "rgb(255,0,255)").
-   */
   get cssColor() {
     const e = this.RGB;
     if (e != null)
       return `rgb(${e >> 16 & 255},${e >> 8 & 255},${e & 255})`;
   }
-  /**
-   * Returns a CSS rgba() color string with the specified alpha value.
-   * @param alpha - Opacity value between 0 (transparent) and 1 (opaque)
-   */
   cssColorAlpha(e) {
     const t = this.RGB;
     if (t != null)
       return `rgba(${t >> 16 & 255},${t >> 8 & 255},${t & 255},${e})`;
   }
-  // ---------------------------------------------------------------------
-  // ACI accessors (ByACI)
-  // ---------------------------------------------------------------------
-  /** Gets the AutoCAD Color Index (ACI), or undefined if not ByACI, ByBlock, or ByLayer. */
   get colorIndex() {
-    return this._colorMethod === i.ByACI ? this._value : this._colorMethod === i.ByLayer ? 256 : this._colorMethod === i.ByBlock ? 0 : void 0;
-  }
-  /**
-   * Sets the AutoCAD Color Index (0–256).
-   *
-   * - 0 sets the color method to `ByBlock`
-   * - 256 sets the color method to `ByLayer`
-   * - 1–255 sets the color method to `ByACI`
-   *
-   * @param index ACI index
-   */
+    return this._colorMethod === n.ByACI ? this._value : this._colorMethod === n.ByLayer ? 256 : this._colorMethod === n.ByBlock ? 0 : void 0;
+  }
   set colorIndex(e) {
     if (e == null) return;
     const t = Math.max(0, Math.min(256, Math.round(e)));
-    t === 0 ? (this._colorMethod = i.ByBlock, this._value = void 0) : t === 256 ? (this._colorMethod = i.ByLayer, this._value = void 0) : (this._colorMethod = i.ByACI, this._value = t);
+    t === 0 ? (this._colorMethod = n.ByBlock, this._value = void 0) : t === 256 ? (this._colorMethod = n.ByLayer, this._value = void 0) : (this._colorMethod = n.ByACI, this._value = t);
   }
-  /**
-   * Returns true if the color method is ByColor (explicit RGB).
-   */
   get isByColor() {
-    return this._colorMethod === i.ByColor;
+    return this._colorMethod === n.ByColor;
   }
-  /**
-   * Returns true if the color method is ByACI.
-   */
   get isByACI() {
-    return this._colorMethod === i.ByACI;
-  }
-  /**
-   * Returns true if the color method is ByACI and ACI value is 7
-   *
-   * Notes:
-   * In AutoCAD, ACI Color 7 (Color Index 7) is officially named "Black" or "White" depending on
-   * the context, but it is functionally defined as the "Contrasting Color" or "Auto-Contrast Color."
-   * Here is the technical explanation of its behavior:
-   * - If the background is dark: Color 7 displays as White.
-   * - If the background is light: Color 7 displays as Black.
-   */
+    return this._colorMethod === n.ByACI;
+  }
   get isForeground() {
-    return this._colorMethod === i.ByACI && this._value === 7;
+    return this._colorMethod === n.ByACI && this._value === 7;
   }
-  /**
-   * Sets the color to ACI value 7.
-   */
   setForeground() {
-    return this._colorMethod = i.ByACI, this._value = 7, this;
+    return this._colorMethod = n.ByACI, this._value = 7, this;
   }
-  // ---------------------------------------------------------------------
-  // Layer / Block helpers
-  // ---------------------------------------------------------------------
-  /** Returns true if the color method is ByLayer. */
   get isByLayer() {
-    return this._colorMethod === i.ByLayer;
+    return this._colorMethod === n.ByLayer;
   }
-  /**
-   * Sets the color to ByLayer.
-   * @param value - Option layer color value
-   */
   setByLayer(e) {
-    return this._colorMethod = i.ByLayer, e == null ? this._value = 256 : this._value = e, this;
+    return this._colorMethod = n.ByLayer, e == null ? this._value = 256 : this._value = e, this;
   }
-  /** Returns true if the color method is ByBlock. */
   get isByBlock() {
-    return this._colorMethod === i.ByBlock;
+    return this._colorMethod === n.ByBlock;
   }
-  /**
-   * Sets the color to ByBlock.
-   * @param value - Option layer color value
-   */
   setByBlock(e) {
-    return this._colorMethod = i.ByBlock, e == null ? this._value = 0 : this._value = e, this;
-  }
-  // ---------------------------------------------------------------------
-  // Color name (dynamic)
-  // ---------------------------------------------------------------------
-  /**
-   * Gets the color name.
-   *
-   * For `ByColor` or `ByACI`, resolves the name via `AcCmColorUtil`.
-   * For `ByLayer` or `ByBlock`, returns the corresponding string.
-   */
+    return this._colorMethod = n.ByBlock, e == null ? this._value = 0 : this._value = e, this;
+  }
   get colorName() {
     switch (this._colorMethod) {
-      case i.ByLayer:
+      case n.ByLayer:
         return "ByLayer";
-      case i.ByBlock:
+      case n.ByBlock:
         return "ByBlock";
-      case i.ByColor:
-        return this._value ? w.getNameByColor(this._value) : "";
-      case i.ByACI:
-        return this._value ? w.getNameByIndex(this._value) : "";
+      case n.ByColor:
+        return this._value ? b.getNameByColor(this._value) : "";
+      case n.ByACI:
+        return this._value ? b.getNameByIndex(this._value) : "";
       default:
         return;
     }
   }
-  /**
-   * Sets the color by name.
-   *
-   * Resolves the name to an RGB value via `AcCmColorUtil`.
-   *
-   * @param name Color name
-   */
   set colorName(e) {
     if (!e) return;
-    const t = w.getColorByName(e);
-    t !== void 0 ? (this._value = t, this._colorMethod = i.ByColor) : console.warn("Unknown color name:", e);
-  }
-  // ---------------------------------------------------------------------
-  // Clone / Copy / Equals
-  // ---------------------------------------------------------------------
-  /**
-   * Creates a clone of this color instance.
-   *
-   * @returns A new AcCmColor instance with the same method and value
-   */
+    const t = b.getColorByName(e);
+    t !== void 0 && (this._value = t, this._colorMethod = n.ByColor);
+  }
   clone() {
-    const e = new _();
+    const e = new B();
     return e._colorMethod = this._colorMethod, e._value = this._value, e;
   }
-  /**
-   * Copies color values from another AcCmColor instance.
-   *
-   * @param other The source color
-   * @returns The current instance
-   */
   copy(e) {
     return this._colorMethod = e._colorMethod, this._value = e._value, this;
   }
-  /**
-   * Checks equality with another color.
-   *
-   * @param other The color to compare
-   * @returns True if color method and value are identical
-   */
   equals(e) {
     return this._colorMethod === e._colorMethod && this._value === e._value;
   }
-  // ---------------------------------------------------------------------
-  // String representation
-  // ---------------------------------------------------------------------
-  /**
-   * Returns a string representation of the color.
-   *
-   * - "ByLayer" for ByLayer colors
-   * - "ByBlock" for ByBlock colors
-   * - One number for color index
-   * - Three comma-separated numbers for RGB color
-   */
   toString() {
     switch (this._colorMethod) {
-      case i.ByLayer:
+      case n.ByLayer:
         return "ByLayer";
-      case i.ByBlock:
+      case n.ByBlock:
         return "ByBlock";
-      case i.ByACI:
+      case n.ByACI:
         return this._value !== void 0 ? String(this._value) : "";
-      case i.ByColor:
+      case n.ByColor:
         return this._value ? `${this.red},${this.green},${this.blue}` : "";
       default:
         return "";
     }
   }
-  /**
-   * Creates one AcCmColor from one string
-   */
   static fromString(e) {
     if (!e) return;
     const t = e.trim();
     if (/^bylayer$/i.test(t))
-      return new _(i.ByLayer);
+      return new B(n.ByLayer);
     if (/^byblock$/i.test(t))
-      return new _(i.ByBlock);
+      return new B(n.ByBlock);
     const s = t.match(
       /^rgb\s*:\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})$/i
     );
     if (s) {
-      const n = Number(s[1]), l = Number(s[2]), c = Number(s[3]), v = new _(i.ByColor);
-      return v.setRGB(n, l, c), v;
+      const i = Number(s[1]), l = Number(s[2]), c = Number(s[3]), v = new B(n.ByColor);
+      return v.setRGB(i, l, c), v;
     }
     if (/^\d{1,3},\d{1,3},\d{1,3}$/.test(t)) {
-      const [n, l, c] = t.split(",").map(Number), v = new _(i.ByColor);
-      return v.setRGB(n, l, c), v;
+      const [i, l, c] = t.split(",").map(Number), v = new B(n.ByColor);
+      return v.setRGB(i, l, c), v;
     }
     if (/^\d+$/.test(t)) {
-      const n = parseInt(t, 10);
-      return new _(i.ByACI, n);
+      const i = parseInt(t, 10);
+      return new B(n.ByACI, i);
     }
     if (/^book\$/i.test(t)) {
-      const n = t.substring(t.indexOf("$") + 1), l = w.getColorByName(n);
-      if (l != null)
-        return new _(i.ByColor, l);
-      console.warn("Unknown color book entry:", e);
-      return;
+      const i = t.substring(t.indexOf("$") + 1), l = b.getColorByName(i);
+      return l != null ? new B(n.ByColor, l) : void 0;
     }
-    const o = w.getColorByName(t);
+    const o = b.getColorByName(t);
     if (o != null)
-      return new _(i.ByColor, o);
-    console.warn("Unknown color name:", e);
+      return new B(n.ByColor, o);
   }
 }
 class oe {
-  /**
-   * Constructs a new `AcCmEntityColor`.
-   *
-   * @param method Initial color method (defaults to `ByColor`)
-   * @param value Internal packed value (defaults to `0`)
-   */
-  constructor(e = i.ByColor, t = 0) {
+  constructor(e = n.ByColor, t = 0) {
     this._colorMethod = e, this._value = t;
   }
-  /**
-   * Gets the method used to determine the final color.
-   */
   get colorMethd() {
     return this._colorMethod;
   }
-  // ---------------------------------------------------------------------
-  // RGB accessors
-  // ---------------------------------------------------------------------
-  /**
-   * Gets the red component (0–255). Only valid when colorMethod = ByColor.
-   */
   get red() {
     return this._value >> 16 & 255;
   }
-  /**
-   * Sets the red component and updates the packed RGB value.
-   */
   set red(e) {
-    this._colorMethod = i.ByColor, this._value = this._value & 65535 | (e & 255) << 16;
+    this._colorMethod = n.ByColor, this._value = this._value & 65535 | (e & 255) << 16;
   }
-  /**
-   * Gets the green component (0–255). Only valid when colorMethod = ByColor.
-   */
   get green() {
     return this._value >> 8 & 255;
   }
-  /**
-   * Sets the green component and updates the packed RGB value.
-   */
   set green(e) {
-    this._colorMethod = i.ByColor, this._value = this._value & 16711935 | (e & 255) << 8;
+    this._colorMethod = n.ByColor, this._value = this._value & 16711935 | (e & 255) << 8;
   }
-  /**
-   * Gets the blue component (0–255). Only valid when colorMethod = ByColor.
-   */
   get blue() {
     return this._value & 255;
   }
-  /**
-   * Sets the blue component and updates the packed RGB value.
-   */
   set blue(e) {
-    this._colorMethod = i.ByColor, this._value = this._value & 16776960 | e & 255;
-  }
-  /**
-   * Sets all RGB components.
-   *
-   * @param r Red (0–255)
-   * @param g Green (0–255)
-   * @param b Blue (0–255)
-   */
+    this._colorMethod = n.ByColor, this._value = this._value & 16776960 | e & 255;
+  }
   setRGB(e, t, s) {
-    this._colorMethod = i.ByColor, this._value = (e & 255) << 16 | (t & 255) << 8 | s & 255;
-  }
-  // ---------------------------------------------------------------------
-  // ACI accessors
-  // ---------------------------------------------------------------------
-  /**
-   * Gets the AutoCAD Color Index (ACI). Only valid when colorMethod = ByACI.
-   */
+    this._colorMethod = n.ByColor, this._value = (e & 255) << 16 | (t & 255) << 8 | s & 255;
+  }
   get colorIndex() {
     return this._value;
   }
-  /**
-   * Sets the AutoCAD Color Index (ACI).
-   */
   set colorIndex(e) {
-    this._colorMethod = i.ByACI, this._value = e;
-  }
-  // ---------------------------------------------------------------------
-  // Layer index accessors
-  // ---------------------------------------------------------------------
-  /**
-   * Gets the referenced layer index. Only valid when colorMethod = ByLayer.
-   */
+    this._colorMethod = n.ByACI, this._value = e;
+  }
   get layerIndex() {
     return this._value;
   }
-  /**
-   * Sets the layer index for ByLayer color mode.
-   */
   set layerIndex(e) {
-    this._colorMethod = i.ByLayer, this._value = e;
-  }
-  // ---------------------------------------------------------------------
-  // Utility methods
-  // ---------------------------------------------------------------------
-  /**
-   * Returns true if the color method is ByColor (explicit RGB).
-   */
+    this._colorMethod = n.ByLayer, this._value = e;
+  }
   isByColor() {
-    return this._colorMethod === i.ByColor;
+    return this._colorMethod === n.ByColor;
   }
-  /**
-   * Returns true if the color method is ByLayer.
-   */
   isByLayer() {
-    return this._colorMethod === i.ByLayer;
+    return this._colorMethod === n.ByLayer;
   }
-  /**
-   * Returns true if the color method is ByBlock.
-   */
   isByBlock() {
-    return this._colorMethod === i.ByBlock;
+    return this._colorMethod === n.ByBlock;
   }
-  /**
-   * Returns true if the color method is ByACI.
-   */
   isByACI() {
-    return this._colorMethod === i.ByACI;
+    return this._colorMethod === n.ByACI;
   }
-  /**
-   * Returns true if color is uninitialized or invalid.
-   */
   isNone() {
-    return this._colorMethod === i.None;
-  }
-  /**
-   * Gets the packed internal value.
-   *
-   * - RGB → packed 24-bit integer
-   * - ACI → index
-   * - Layer → index
-   */
+    return this._colorMethod === n.None;
+  }
   get rawValue() {
     return this._value;
   }
-  /**
-   * Sets a raw internal value. The meaning depends on `colorMethod`.
-   */
   set rawValue(e) {
     this._value = e;
   }
 }
-const ne = {
-  /**
-   * Throw error ILLEGAL_PARAMETERS when cannot instantiate from given parameter
-   */
+const ie = {
   get ILLEGAL_PARAMETERS() {
     return new ReferenceError("Illegal Parameters");
   },
-  /**
-   * Throw error ZERO_DIVISION to catch situation of zero division
-   */
   get ZERO_DIVISION() {
     return new Error("Zero division");
   },
-  /**
-   * Error to throw from BooleanOperations module in case when fixBoundaryConflicts not capable to fix it
-   */
   get UNRESOLVED_BOUNDARY_CONFLICT() {
     return new Error("Unresolved boundary conflict in boolean operation");
   },
-  /**
-   * Error to throw from LinkedList:testInfiniteLoop static method
-   * in case when circular loop detected in linked list
-   */
   get INFINITE_LOOP() {
     return new Error("Infinite loop");
   },
@@ -1033,10 +709,7 @@ const ne = {
     return new Error("Not implemented yet");
   }
 };
-class ie {
-  /**
-   * Creates {@link AcCmEventDispatcher} object.
-   */
+class ne {
   constructor() {
     this._listeners = {};
   }
@@ -1054,54 +727,34 @@ class ie {
     if (this._listeners === void 0) return;
     const o = this._listeners[e];
     if (o !== void 0) {
-      const n = o.indexOf(t);
-      n !== -1 && o.splice(n, 1);
+      const i = o.indexOf(t);
+      i !== -1 && o.splice(i, 1);
     }
   }
-  /**
-   * Fire an event type.
-   * @param event The event that gets fired.
-   */
   dispatchEvent(e) {
     if (this._listeners === void 0) return;
     const s = this._listeners[e.type];
     if (s !== void 0) {
       e.target = this;
       const o = s.slice(0);
-      for (let n = 0, l = o.length; n < l; n++)
-        o[n].call(this, e);
+      for (let i = 0, l = o.length; i < l; i++)
+        o[i].call(this, e);
     }
   }
 }
-class U {
+class F {
   constructor() {
     this.listeners = [];
   }
-  /**
-   * Add the event listener
-   * @param listener Input listener to be added
-   */
   addEventListener(e) {
     this.listeners.push(e);
   }
-  /**
-   * Remove the listener
-   * @param listener Input listener to be removed
-   */
   removeEventListener(e) {
     this.listeners = this.listeners.filter((t) => t !== e);
   }
-  /**
-   * Remove all listeners bound to the target and add one new listener
-   * @param listener Input listener to be added
-   */
   replaceEventListener(e) {
     this.removeEventListener(e), this.addEventListener(e);
   }
-  /**
-   * Notify all listeners
-   * @param payload Input payload passed to listener
-   */
   dispatch(e, ...t) {
     for (const s of this.listeners)
       s.call(null, e, ...t);
@@ -1110,7 +763,7 @@ class U {
 function C(r) {
   return r === null || typeof r != "object" ? r : Array.isArray(r) ? [...r] : { ...r };
 }
-function F(r) {
+function U(r) {
   if (r === null || typeof r != "object")
     return r;
   if (r instanceof Date)
@@ -1118,10 +771,10 @@ function F(r) {
   if (r instanceof RegExp)
     return new RegExp(r.source, r.flags);
   if (Array.isArray(r))
-    return r.map(F);
+    return r.map(U);
   const e = {};
   for (const t in r)
-    Object.prototype.hasOwnProperty.call(r, t) && (e[t] = F(r[t]));
+    Object.prototype.hasOwnProperty.call(r, t) && (e[t] = U(r[t]));
   return e;
 }
 function Y(r, ...e) {
@@ -1186,7 +839,7 @@ var D = { exports: {} };
       "info",
       "warn",
       "error"
-    ], n = {}, l = null;
+    ], i = {}, l = null;
     function c(h, d) {
       var a = h[d];
       if (typeof a.bind == "function")
@@ -1200,9 +853,9 @@ var D = { exports: {} };
       }
     }
     function v() {
-      console.log && (console.log.apply ? console.log.apply(console, arguments) : Function.prototype.apply.apply(console.log, [console, arguments])), console.trace && console.trace();
+      console.log && (console.log.apply || Function.prototype.apply.apply(console.log, [console, arguments]));
     }
-    function b(h) {
+    function w(h) {
       return h === "debug" && (h = "log"), typeof console === t ? !1 : h === "trace" && s ? v : console[h] !== void 0 ? c(console, h) : console.log !== void 0 ? c(console, "log") : e;
     }
     function m() {
@@ -1219,7 +872,7 @@ var D = { exports: {} };
       };
     }
     function f(h, d, a) {
-      return b(h) || x.apply(this, arguments);
+      return w(h) || x.apply(this, arguments);
     }
     function S(h, d) {
       var a = this, E, N, L, p = "loglevel";
@@ -1268,7 +921,7 @@ var D = { exports: {} };
           }
         }
       }
-      function k(u) {
+      function M(u) {
         var g = u;
         if (typeof g == "string" && a.levels[g.toUpperCase()] !== void 0 && (g = a.levels[g.toUpperCase()]), typeof g == "number" && g >= 0 && g <= a.levels.SILENT)
           return g;
@@ -1284,9 +937,9 @@ var D = { exports: {} };
       }, a.methodFactory = d || f, a.getLevel = function() {
         return L ?? N ?? E;
       }, a.setLevel = function(u, g) {
-        return L = k(u), g !== !1 && z(L), m.call(a);
+        return L = M(u), g !== !1 && z(L), m.call(a);
       }, a.setDefaultLevel = function(u) {
-        N = k(u), P() || a.setLevel(u, !1);
+        N = M(u), P() || a.setLevel(u, !1);
       }, a.resetLevel = function() {
         L = null, H(), m.call(a);
       }, a.enableAll = function(u) {
@@ -1294,20 +947,20 @@ var D = { exports: {} };
       }, a.disableAll = function(u) {
         a.setLevel(a.levels.SILENT, u);
       }, a.rebuild = function() {
-        if (l !== a && (E = k(l.getLevel())), m.call(a), l === a)
-          for (var u in n)
-            n[u].rebuild();
-      }, E = k(
+        if (l !== a && (E = M(l.getLevel())), m.call(a), l === a)
+          for (var u in i)
+            i[u].rebuild();
+      }, E = M(
         l ? l.getLevel() : "WARN"
       );
       var T = P();
-      T != null && (L = k(T)), m.call(a);
+      T != null && (L = M(T)), m.call(a);
     }
     l = new S(), l.getLogger = function(d) {
       if (typeof d != "symbol" && typeof d != "string" || d === "")
         throw new TypeError("You must supply a name when creating a logger.");
-      var a = n[d];
-      return a || (a = n[d] = new S(
+      var a = i[d];
+      return a || (a = i[d] = new S(
         d,
         l.methodFactory
       )), a;
@@ -1316,15 +969,12 @@ var D = { exports: {} };
     return l.noConflict = function() {
       return typeof window !== t && window.log === l && (window.log = j), l;
     }, l.getLoggers = function() {
-      return n;
+      return i;
     }, l.default = l, l;
   });
 })(D);
 var q = D.exports;
-const ee = /* @__PURE__ */ Q(q), te = /* @__PURE__ */ W({
-  __proto__: null,
-  default: ee
-}, [q]), le = !0, O = te;
+const ee = /* @__PURE__ */ Q(q), te = /* @__PURE__ */ W({ __proto__: null, default: ee }, [q]), le = !0, O = te;
 O.setLevel("debug");
 const ae = (r) => {
   try {
@@ -1334,46 +984,14 @@ const ae = (r) => {
   }
 };
 class V {
-  /**
-   * Create one object to store attributes. For performance reason, values of attributes passed to constructor
-   * will not be cloned to `attributes` property. So it means that value of `attributes` property in this object
-   * is just a reference to arguments `attributes` passed to constructor.
-   * @param attributes Input attributes to store in this object
-   */
   constructor(e, t) {
     this.events = {
-      attrChanged: new U(),
-      modelChanged: new U()
+      attrChanged: new F(),
+      modelChanged: new F()
     }, this._changing = !1, this._previousAttributes = {}, this._pending = !1;
     const s = e || {};
     t && Y(s, t), this.attributes = s, this.changed = {};
   }
-  /**
-   * Gets the value of an attribute.
-   *
-   * For strongly-typed access to attributes, use the `get` method privately in public getter properties.
-   *
-   * @template A - The key type extending string keys of T.
-   * @param {A} key - The attribute key to retrieve.
-   * @returns {T[A] | undefined} The attribute value or undefined if not set.
-   *
-   * @example
-   * ```typescript
-   * // Get a single attribute value
-   * const name = obj.get('name')
-   * const visible = obj.get('visible')
-   *
-   * // Check if attribute exists
-   * if (obj.get('name') !== undefined) {
-   *   console.log('Name is set')
-   * }
-   *
-   * // For strongly-typed subclasses
-   * get name(): string {
-   *   return super.get("name")
-   * }
-   * ```
-   */
   get(e) {
     return this.attributes[e];
   }
@@ -1381,18 +999,18 @@ class V {
     if (e == null) return this;
     let o;
     typeof e == "object" ? (o = e, s = t) : (o = {}, o[e] = t), s || (s = {});
-    const n = s.unset, l = s.silent, c = [], v = this._changing;
+    const i = s.unset, l = s.silent, c = [], v = this._changing;
     this._changing = !0, v || (this._previousAttributes = C(this.attributes), this.changed = {});
-    const b = this.attributes, m = this.changed, x = this._previousAttributes;
+    const w = this.attributes, m = this.changed, x = this._previousAttributes;
     for (const f in o)
-      t = o[f], I(b[f], t) || c.push(f), I(x[f], t) ? delete m[f] : m[f] = t, n ? delete b[f] : b[f] = t;
+      t = o[f], I(w[f], t) || c.push(f), I(x[f], t) ? delete m[f] : m[f] = t, i ? delete w[f] : w[f] = t;
     if (!l) {
       c.length && (this._pending = s);
       for (let f = 0; f < c.length; f++)
         this.events.attrChanged.dispatch({
           object: this,
           attrName: c[f],
-          attrValue: b[c[f]],
+          attrValue: w[c[f]],
           options: s
         });
     }
@@ -1408,398 +1026,147 @@ class V {
   has(e) {
     return this.get(e) != null;
   }
-  /**
-   * Determine if the model has changed since the last `"change"` event.
-   * If you specify an attribute name, determine if that attribute has changed.
-   */
   hasChanged(e) {
     return e == null ? !J(this.changed) : Z(this.changed, e);
   }
-  /**
-   * Return an object containing all the attributes that have changed. Useful for determining what parts
-   * of a view need to be updated and/or what attributes need to be persisted to the server.
-   *
-   * Unset attributes will be set to undefined. You can also pass an attributes object to diff against
-   * the model, determining if there *would be* a change.
-   */
   changedAttributes(e) {
     if (!e) return this.hasChanged() ? C(this.changed) : {};
     const t = this._changing ? this._previousAttributes : this.attributes, s = {};
     for (const o in e) {
-      const n = e[o];
-      I(t[o], n) || (s[o] = n);
+      const i = e[o];
+      I(t[o], i) || (s[o] = i);
     }
     return s;
   }
-  /**
-   * Get the previous value of an attribute, recorded at the time the last `"change"` event was fired.
-   */
   previous(e) {
     return e == null || !this._previousAttributes ? null : this._previousAttributes[e];
   }
-  /**
-   * Get all of the attributes of the model at the time of the previous `"change"` event.
-   */
   previousAttributes() {
     return C(this._previousAttributes);
   }
-  /**
-   * Create a new model with identical attributes to this one.
-   */
   clone() {
     const e = C(this.attributes);
     return new V(e);
   }
 }
-class M {
-  /**
-   * Private constructor to enforce singleton pattern.
-   */
+class k {
   constructor() {
     this.entries = /* @__PURE__ */ new Map();
   }
-  /**
-   * Retrieves the singleton instance of the AcCmPerformanceCollector.
-   * @returns The shared AcCmPerformanceCollector instance.
-   */
   static getInstance() {
-    return M.instance || (M.instance = new M()), M.instance;
+    return k.instance || (k.instance = new k()), k.instance;
   }
-  /**
-   * Adds or replaces a performance entry by name.
-   * @template T The type of the performance data.
-   * @param entry A performance entry object with name, data, and format method.
-   */
   collect(e) {
     this.entries.set(e.name, e);
   }
-  /**
-   * Logs all performance entries to the console using their format method.
-   */
   printAll() {
     for (const [e, t] of this.entries)
-      console.log(`${e}:`), console.log(t.format());
+      ;
   }
-  /**
-   * Clears all collected performance entries.
-   */
   clear() {
     this.entries.clear();
   }
-  /**
-   * Retrieves all entries as an array.
-   * @returns A copy of all performance entries.
-   */
   getAll() {
     return Array.from(this.entries.values());
   }
-  /**
-   * Gets a single entry by name.
-   * @param name The unique name of the entry.
-   * @returns The matching entry or undefined.
-   */
   getEntry(e) {
     return this.entries.get(e);
   }
-  /**
-   * Removes an entry by name.
-   * @param name The name of the entry to remove.
-   * @returns True if the entry was removed; false if not found.
-   */
   remove(e) {
     return this.entries.delete(e);
   }
 }
 class he {
-  /**
-   * Converts a byte count to a human-readable string using appropriate size units.
-   *
-   * Automatically selects the most appropriate unit (B, KB, MB, GB, TB) based on the size
-   * and formats the result with the specified number of decimal places.
-   *
-   * @param {number} bytes - The number of bytes to format.
-   * @param {number} [decimals=2] - Number of decimal places to include in the result.
-   * @returns {string} A formatted string with the appropriate unit.
-   *
-   * @example
-   * ```typescript
-   * import { AcTrStringUtil } from './AcCmStringUtil'
-   *
-   * // Format different byte sizes
-   * AcTrStringUtil.formatBytes(0)          // "0 B"
-   * AcTrStringUtil.formatBytes(1024)       // "1 KB"
-   * AcTrStringUtil.formatBytes(1024 * 1024) // "1 MB"
-   * AcTrStringUtil.formatBytes(1536, 1)    // "1.5 KB"
-   * AcTrStringUtil.formatBytes(2048000, 0) // "2 MB"
-   * ```
-   */
   static formatBytes(e, t = 2) {
     if (e === 0) return "0 B";
-    const s = 1024, o = Math.max(0, t), n = ["B", "KB", "MB", "GB", "TB"], l = Math.floor(Math.log(e) / Math.log(s)), c = e / Math.pow(s, l);
-    return `${parseFloat(c.toFixed(o))} ${n[l]}`;
+    const s = 1024, o = Math.max(0, t), i = ["B", "KB", "MB", "GB", "TB"], l = Math.floor(Math.log(e) / Math.log(s)), c = e / Math.pow(s, l);
+    return `${parseFloat(c.toFixed(o))} ${i[l]}`;
   }
 }
 var y = /* @__PURE__ */ ((r) => (r[r.ByLayer = 0] = "ByLayer", r[r.ByBlock = 1] = "ByBlock", r[r.ByAlpha = 2] = "ByAlpha", r[r.ErrorValue = 3] = "ErrorValue", r))(y || {});
-class B {
-  /**
-   * Creates a new transparency object.
-   *
-   * @param alpha
-   *   When provided, constructs with `ByAlpha` method and sets alpha.
-   *   Must be between 0 and 255.
-   */
+class _ {
   constructor(e) {
-    e !== void 0 ? (this._method = y.ByAlpha, this._alpha = B.clampAlpha(e)) : (this._method = y.ByLayer, this._alpha = 255);
+    e !== void 0 ? (this._method = y.ByAlpha, this._alpha = _.clampAlpha(e)) : (this._method = y.ByLayer, this._alpha = 255);
   }
-  /** Gets the current transparency method */
   get method() {
     return this._method;
   }
-  /**
-   * Sets the transparency method.
-   * If setting to ByAlpha with no prior alpha, alpha stays 255 (opaque).
-   *
-   * @param method The new transparency method
-   */
   set method(e) {
     this._method = e;
   }
-  /**
-   * Gets the alpha value.
-   * Only meaningful if `method === ByAlpha`.
-   */
   get alpha() {
     return this._alpha;
   }
-  /**
-   * Sets the alpha value and force the method to `ByAlpha`.
-   *
-   * @param alpha 0–255 alpha, clamped internally if out of range
-   */
   set alpha(e) {
-    this._alpha = B.clampAlpha(e), this._method = y.ByAlpha;
-  }
-  /**
-   * Gets the AutoCAD-style transparency percentage.
-   *
-   * Mapping rules:
-   * - 0%   = fully opaque  (alpha = 255)
-   * - 100% = fully transparent (alpha = 0)
-   *
-   * This matches how AutoCAD displays and stores transparency
-   * values in UI and DXF files.
-   *
-   * If the transparency method is not `ByAlpha`,
-   * this method returns `undefined`, because AutoCAD
-   * does not define a percentage for ByLayer or ByBlock.
-   *
-   * @returns Transparency percentage (0–100), or undefined
-   */
+    this._alpha = _.clampAlpha(e), this._method = y.ByAlpha;
+  }
   get percentage() {
     if (this._method === y.ByAlpha)
       return Math.round((1 - this._alpha / 255) * 100);
   }
-  /**
-   * Sets the transparency using an AutoCAD-style percentage.
-   *
-   * Mapping rules (AutoCAD compatible):
-   * - 0%   → fully opaque      (alpha = 255)
-   * - 100% → fully transparent (alpha = 0)
-   *
-   * Internally, the alpha value is calculated as:
-   *   alpha = round(255 × (1 − percentage / 100))
-   *
-   * This method:
-   * - Forces the transparency method to `ByAlpha`
-   * - Clamps the percentage to the range 0–100
-   * - Preserves ObjectARX value semantics
-   *
-   * @param percentage Transparency percentage (0–100)
-   * @returns This instance (for fluent chaining)
-   *
-   * @example
-   * const t = new AcCmTransparency();
-   * t.setPercentage(50); // ≈ alpha 128
-   *
-   * t.setPercentage(0);   // alpha = 255 (opaque)
-   * t.setPercentage(100); // alpha = 0   (clear)
-   */
   set percentage(e) {
     const t = Math.max(0, Math.min(100, e)), s = Math.round(255 * (1 - t / 100));
     this.alpha = s;
   }
-  /**
-   * Ensures alpha always stays within 0–255.
-   */
   static clampAlpha(e) {
     return Math.max(0, Math.min(255, Math.floor(e)));
   }
-  /**
-   * True if the method is `ByAlpha`.
-   */
   get isByAlpha() {
     return this._method === y.ByAlpha;
   }
-  /**
-   * True if the method is `ByBlock`.
-   */
   get isByBlock() {
     return this._method === y.ByBlock;
   }
-  /**
-   * True if the method is `ByLayer`.
-   */
   get isByLayer() {
     return this._method === y.ByLayer;
   }
-  /**
-   * True if transparency is exactly clear (alpha==0 and ByAlpha).
-   */
   get isClear() {
     return this.isByAlpha && this._alpha === 0;
   }
-  /**
-   * True if transparency is solid (alpha==255 and ByAlpha).
-   */
   get isSolid() {
     return this.isByAlpha && this._alpha === 255;
   }
-  /**
-   * True if current state is invalid (ErrorValue).
-   */
   get isInvalid() {
     return this._method === y.ErrorValue;
   }
-  /**
-   * Convert this transparency to an integer suitable for storage.
-   * Uses a simple bit-encoding: high­bits for method and low­bits for alpha.
-   *
-   * 31          24 23          8 7          0
-   * +-------------+--------------+------------+
-   * |  flags      |   reserved   |  alpha     |
-   * +-------------+--------------+------------+
-   */
   serialize() {
     return this._method << 24 | this._alpha;
   }
-  /**
-   * Creates a deep copy of this transparency object.
-   *
-   * This mirrors the value-semantics of ObjectARX `AcCmTransparency`,
-   * where copying results in an independent object with the same
-   * transparency method and alpha value.
-   *
-   * @returns A new `AcCmTransparency` instance with identical state.
-   */
   clone() {
-    const e = new B();
+    const e = new _();
     return e._method = this._method, e._alpha = this._alpha, e;
   }
-  /**
-   * Compares this transparency with another one for equality.
-   *
-   * Two `AcCmTransparency` objects are considered equal if:
-   * - Their transparency methods are identical
-   * - Their alpha values are identical
-   *
-   * This mirrors the value semantics of ObjectARX
-   * `AcCmTransparency`.
-   *
-   * @param other The transparency to compare with
-   * @returns True if both represent the same transparency
-   *
-   * @example
-   * const a = new AcCmTransparency(128);
-   * const b = new AcCmTransparency(128);
-   * a.equals(b); // true
-   */
   equals(e) {
     return this._method === e._method && this._alpha === e._alpha;
   }
-  /**
-   * Returns a human-readable string representation of the transparency.
-   *
-   * Behavior:
-   * - `"ByLayer"` if transparency is inherited from layer
-   * - `"ByBlock"` if transparency is inherited from block
-   * - Numeric alpha value (`"0"`–`"255"`) if method is `ByAlpha`
-   *
-   * This format is intentionally simple and mirrors common
-   * AutoCAD UI and DXF text usage.
-   *
-   * @returns String representation of the transparency
-   *
-   * @example
-   * new AcCmTransparency().toString();        // "ByLayer"
-   * new AcCmTransparency(128).toString();     // "128"
-   */
   toString() {
     return this.isByLayer ? "ByLayer" : this.isByBlock ? "ByBlock" : this._alpha.toString();
   }
-  /**
-   * Creates an `AcCmTransparency` instance from a string representation.
-   *
-   * Accepted formats:
-   * - `"ByLayer"` (case-insensitive)
-   * - `"ByBlock"` (case-insensitive)
-   * - Numeric alpha value `"0"`–`"255"`
-   *
-   * Invalid or out-of-range values will produce an
-   * `ErrorValue` transparency.
-   *
-   * @param value String to parse
-   * @returns Parsed `AcCmTransparency` instance
-   *
-   * @example
-   * AcCmTransparency.fromString("ByLayer");
-   * AcCmTransparency.fromString("128");
-   * AcCmTransparency.fromString("ByBlock");
-   */
   static fromString(e) {
     const t = e.trim();
     if (/^bylayer$/i.test(t)) {
-      const n = new B();
-      return n._method = y.ByLayer, n;
+      const i = new _();
+      return i._method = y.ByLayer, i;
     }
     if (/^byblock$/i.test(t)) {
-      const n = new B();
-      return n._method = y.ByBlock, n;
+      const i = new _();
+      return i._method = y.ByBlock, i;
     }
     const s = Number(t);
     if (Number.isInteger(s) && s >= 0 && s <= 255)
-      return new B(s);
-    const o = new B();
+      return new _(s);
+    const o = new _();
     return o._method = y.ErrorValue, o;
   }
-  /**
-   * Deserialize an integer back into a transparency object.
-   *
-   * @param value 32-bit stored transparency representation
-   */
   static deserialize(e) {
-    const t = e >>> 24 & 255, s = e & 255, o = Object.values(y)[t] ?? y.ErrorValue, n = new B();
-    return n._method = o, n._alpha = B.clampAlpha(s), n;
+    const t = e >>> 24 & 255, s = e & 255, o = Object.values(y)[t] ?? y.ErrorValue, i = new _();
+    return i._method = o, i._alpha = _.clampAlpha(s), i;
   }
 }
 class ue {
-  /**
-   * Creates a new task with the specified name.
-   *
-   * @param {string} name - The name identifier for this task.
-   */
   constructor(e) {
     this.name = e;
   }
-  /**
-   * Executes the task with the given input.
-   *
-   * This method must be implemented by subclasses to define the actual work
-   * performed by the task. Can return either a synchronous result or a Promise.
-   *
-   * @param {TIn} _input - The input data for the task.
-   * @returns {TOut | Promise<TOut>} The task result, either synchronous or asynchronous.
-   * @throws {Error} When the method is not implemented by a subclass.
-   */
   run(e) {
     throw new Error("run() must be implemented by subclass");
   }
@@ -1810,15 +1177,6 @@ class ce {
     }, this.onComplete = () => {
     }, this.onError = () => !1;
   }
-  /**
-   * Schedules a task to be executed asynchronously.
-   *
-   * This method uses requestAnimationFrame in browser environments or setTimeout
-   * in Node.js environments to schedule the task.
-   *
-   * @param callback - The callback function to schedule
-   * @returns Promise that resolves with the result of the callback
-   */
   scheduleTask(e) {
     return new Promise((t, s) => {
       const o = () => {
@@ -1827,47 +1185,30 @@ class ce {
       typeof window < "u" && typeof window.requestAnimationFrame == "function" ? window.requestAnimationFrame(o) : setTimeout(o, 0);
     });
   }
-  /**
-   * Adds a task to the execution queue.
-   *
-   * @param task Task instance with name and run function
-   */
   addTask(e) {
     this.tasks.push(e);
   }
-  /**
-   * Sets a callback to receive progress updates.
-   */
   setProgressCallback(e) {
     this.onProgress = e;
   }
-  /**
-   * Sets a callback to be called after successful completion of all tasks.
-   */
   setCompleteCallback(e) {
     this.onComplete = e;
   }
-  /**
-   * Sets a callback to be called if any task throws an error.
-   */
   setErrorCallback(e) {
     this.onError = e;
   }
-  /**
-   * Starts execution of the task queue with the given initial input.
-   */
   async run(e) {
     const t = this.tasks.length;
     let s = e;
     for (let o = 0; o < t; o++) {
-      const n = this.tasks[o];
+      const i = this.tasks[o];
       try {
         s = await this.scheduleTask(async () => {
-          const l = await n.run(s);
-          return this.onProgress((o + 1) / t, n), l;
+          const l = await i.run(s);
+          return this.onProgress((o + 1) / t, i), l;
         });
       } catch (l) {
-        if (this.onError({ error: l, taskIndex: o, task: n }))
+        if (this.onError({ error: l, taskIndex: o, task: i }))
           return Promise.reject(l);
       }
     }
@@ -1875,182 +1216,89 @@ class ce {
   }
 }
 class re {
-  /**
-   * Create a new AcCmLoadingManager instance
-   * @param onLoad this function will be called when all loaders are done.
-   * @param onProgress this function will be called when an item is complete.
-   * @param onError this function will be called a loader encounters errors.
-   */
   constructor(e, t, s) {
     this.isLoading = !1, this.itemsLoaded = 0, this.itemsTotal = 0, this.urlModifier = void 0, this.handlers = [], this.onStart = void 0, this.onLoad = e, this.onProgress = t, this.onError = s;
   }
-  /**
-   * This should be called by any loader using the manager when the loader starts loading an url.
-   * @param url The loaded url
-   */
   itemStart(e) {
     this.itemsTotal++, this.isLoading === !1 && this.onStart !== void 0 && this.onStart(e, this.itemsLoaded, this.itemsTotal), this.isLoading = !0;
   }
-  /**
-   * This should be called by any loader using the manager when the loader ended loading an url.
-   * @param url The loaded url
-   */
   itemEnd(e) {
     this.itemsLoaded++, this.onProgress !== void 0 && this.onProgress(e, this.itemsLoaded, this.itemsTotal), this.itemsLoaded === this.itemsTotal && (this.isLoading = !1, this.onLoad !== void 0 && this.onLoad());
   }
-  /**
-   * This should be called by any loader using the manager when the loader errors loading an url.
-   * @param url The loaded url
-   */
   itemError(e) {
     this.onError !== void 0 && this.onError(e);
   }
-  /**
-   * Given a URL, uses the URL modifier callback (if any) and returns a resolved URL. If no URL
-   * modifier is set, returns the original URL.
-   * @param url The url to load
-   * @returns Return resolved URL
-   */
   resolveURL(e) {
     return this.urlModifier ? this.urlModifier(e) : e;
   }
-  /**
-   * If provided, the callback will be passed each resource URL before a request is sent. The callback
-   * may return the original URL, or a new URL to override loading behavior. This behavior can be used
-   * to load assets from .ZIP files, drag-and-drop APIs, and Data URIs.
-   * @param transform URL modifier callback. Called with url argument, and must return resolvedURL.
-   * @returns Return this object
-   */
   setURLModifier(e) {
     return this.urlModifier = e, this;
   }
-  /**
-   * Register a loader with the given regular expression. Can be used to define what loader should
-   * be used in order to load specific files. A typical use case is to overwrite the default loader
-   * for textures.
-   * @param regex A regular expression.
-   * @param loader The loader.
-   * @returns Return this object
-   */
   addHandler(e, t) {
     return this.handlers.push(e, t), this;
   }
-  /**
-   * Remove the loader for the given regular expression.
-   * @param regex A regular expression.
-   * @returns Return this object
-   */
   removeHandler(e) {
     const t = this.handlers.indexOf(e);
     return t !== -1 && this.handlers.splice(t, 2), this;
   }
-  /**
-   * Retrieve the registered loader for the given file path.
-   * @param file The file path.
-   * @returns Return the registered loader for the given file path.
-   */
   getHandler(e) {
     for (let t = 0, s = this.handlers.length; t < s; t += 2) {
-      const o = this.handlers[t], n = this.handlers[t + 1];
+      const o = this.handlers[t], i = this.handlers[t + 1];
       if (o.global && (o.lastIndex = 0), o.test(e))
-        return n;
+        return i;
     }
     return null;
   }
 }
-const se = /* @__PURE__ */ new re();
+const se = new re();
 class de {
-  /**
-   * Creates a new AcCmLoader instance.
-   * @param manager The loadingManager for the loader to use. Default is DefaultLoadingManager.
-   */
   constructor(e) {
     this.manager = e !== void 0 ? e : se, this.crossOrigin = "anonymous", this.withCredentials = !1, this.path = "", this.resourcePath = "", this.requestHeader = {};
   }
-  /**
-   * This method is equivalent to 'load', but returns a Promise.
-   * @param url A string containing the path/URL of the file to be loaded.
-   * @param onProgress (optional) — A function to be called while the loading is in progress.
-   * The argument will be the ProgressEvent instance, which contains .lengthComputable, .total
-   * and .loaded. If the server does not set the Content-Length header; .total will be 0.
-   * @returns Return a promise.
-   */
   loadAsync(e, t) {
     return new Promise((s, o) => {
       this.load(e, s, t, o);
     });
   }
-  /**
-   * This method needs to be implement by all concrete loaders. It holds the logic for parsing the asset.
-   */
   parse(e) {
   }
-  /**
-   * Set the crossOrigin string to implement CORS for loading the url from a different domain that allows
-   * CORS.
-   * @param crossOrigin The crossOrigin string
-   * @returns Return this object
-   */
   setCrossOrigin(e) {
     return this.crossOrigin = e, this;
   }
-  /**
-   * Set whether the XMLHttpRequest uses credentials such as cookies, authorization headers or TLS
-   * client certificates.
-   * Note that this has no effect if you are loading files locally or from the same domain.
-   * @param value The flag whether the XMLHttpRequest uses credentials.
-   * @returns Return this object
-   */
   setWithCredentials(e) {
     return this.withCredentials = e, this;
   }
-  /**
-   * Set the base path for the asset.
-   * @param path The base path for the asset.
-   * @returns Return this object
-   */
   setPath(e) {
     return this.path = e, this;
   }
-  /**
-   * Set the base path for dependent resources like textures.
-   * @param resourcePath The base path for dependent resources like textures.
-   * @returns Return this object
-   */
   setResourcePath(e) {
     return this.resourcePath = e, this;
   }
-  /**
-   * Set the request header used in HTTP request.
-   * @param requestHeader  key: The name of the header whose value is to be set. value: The value
-   * to set as the body of the header.
-   * @returns Return this object
-   */
   setRequestHeader(e) {
     return this.requestHeader = e, this;
   }
 }
 export {
-  _ as AcCmColor,
-  i as AcCmColorMethod,
-  w as AcCmColorUtil,
+  B as AcCmColor,
+  n as AcCmColorMethod,
+  b as AcCmColorUtil,
   oe as AcCmEntityColor,
-  ne as AcCmErrors,
-  ie as AcCmEventDispatcher,
-  U as AcCmEventManager,
+  ie as AcCmErrors,
+  ne as AcCmEventDispatcher,
+  F as AcCmEventManager,
   de as AcCmLoader,
   re as AcCmLoadingManager,
   V as AcCmObject,
-  M as AcCmPerformanceCollector,
+  k as AcCmPerformanceCollector,
   ue as AcCmTask,
   ce as AcCmTaskScheduler,
-  B as AcCmTransparency,
+  _ as AcCmTransparency,
   y as AcCmTransparencyMethod,
   he as AcTrStringUtil,
   le as DEBUG_MODE,
   se as DefaultLoadingManager,
   C as clone,
-  F as deepClone,
+  U as deepClone,
   Y as defaults,
   Z as has,
   J as isEmpty,