@mlightcad/common 1.2.5 → 1.2.7

package/dist/common.js

@@ -1,20 +1,21 @@
-function H(n, e) {
+function W(r, e) {
   for (var t = 0; t < e.length; t++) {
-    const r = e[t];
-    if (typeof r != "string" && !Array.isArray(r)) {
-      for (const o in r)
-        if (o !== "default" && !(o in n)) {
-          const i = Object.getOwnPropertyDescriptor(r, o);
-          i && Object.defineProperty(n, o, i.get ? i : {
+    const s = e[t];
+    if (typeof s != "string" && !Array.isArray(s)) {
+      for (const o in s)
+        if (o !== "default" && !(o in r)) {
+          const i = Object.getOwnPropertyDescriptor(s, o);
+          i && Object.defineProperty(r, o, i.get ? i : {
             enumerable: !0,
-            get: () => r[o]
+            get: () => s[o]
           });
         }
     }
   }
-  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
 }
-const 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,
   aqua: 65535,
@@ -159,7 +160,7 @@ const I = {
   whitesmoke: 16119285,
   yellow: 16776960,
   yellowgreen: 10145074
-}, T = [
+}, N = [
   0,
   16711680,
   16776960,
@@ -418,266 +419,543 @@ const I = {
   16777215,
   0
 ];
-function w(n, e, t) {
-  return Math.max(e, Math.min(t, n));
-}
-const C = class C {
+class b {
   /**
-   * Constructs a new AcCmColor instance.
-   * Initializes the color to "ByLayer" (index 256) and null RGB values.
+   * 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
+   * ```
    */
-  constructor() {
-    this._colorIndex = 256, this._color = null, this._colorName = null;
+  static getColorByIndex(e) {
+    return N[e];
   }
   /**
-   * Gets the current color value.
+   * Finds the AutoCAD color index associated with a given RGB value.
    *
-   * @returns {number | null} The color value (RGB or index).
+   * @private
+   * @param {number} color - The RGB value to find an index for.
+   * @returns {number | undefined} The color index if found, undefined otherwise.
    */
-  get color() {
-    return this._color;
+  static getIndexByColor(e) {
+    const t = N.length - 1;
+    for (let s = 1; s < t; ++s)
+      if (N[s] === e)
+        return s;
   }
   /**
-   * Sets the color value.
+   * 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)
+   * ```
    *
-   * @param {number | null} value - The color value to set (RGB or index).
+   * @example
+   * ```typescript
+   * // Handle undefined for unknown color names
+   * const unknownColor = AcCmColorUtil.getColorByName("unknown"); // returns undefined
+   * ```
    */
-  set color(e) {
-    e == null ? this._color = null : (this._color = Math.round(w(e, 0, 256 * 256 * 256 - 1)), this._colorIndex = this.getColorIndexByValue(this._color), this._colorName = this.getColorNameByValue(this._color));
+  static getColorByName(e) {
+    return G[e.toLowerCase()];
   }
   /**
-   * Gets the hexadecimal representation of the current color.
+   * Finds the color name associated with a given RGB value.
    *
-   * @returns {string} The hexadecimal color string (e.g., "0xFFFFFF").
+   * @param {number} rgb - The RGB value to find a name for.
+   * @returns {string | undefined} The color name if found, undefined otherwise.
    */
-  get hexColor() {
-    if (this._color && this._color > 0 && this._color <= 16777215) {
-      let e = this._color.toString(16).toUpperCase();
-      for (; e.length < 6; )
-        e = "0" + e;
-      return `0x${e}`;
-    }
-    return "";
+  static getNameByColor(e) {
+    for (const [t, s] of Object.entries(G))
+      if (s === e)
+        return t;
   }
   /**
-   * Gets the CSS RGB color string representation.
+   * Finds the color name associated with a given color index.
    *
-   * @returns {string} The CSS RGB color string (e.g., "rgb(255,255,255)").
+   * @param {number} index - The color index to find a name for.
+   * @returns {string | undefined} The color name if found, undefined otherwise.
    */
-  get cssColor() {
-    return `rgb(${this.red},${this.green},${this.blue})`;
+  static getNameByIndex(e) {
+    const t = this.getColorByIndex(e);
+    return this.getNameByColor(t);
   }
+}
+class B {
   /**
-   * Gets the red component of the current color.
-   *
-   * @returns {number | null} The red component (0-255).
+   * Constructs a new AcCmColor.
+   * @param method Initial color method (defaults to `ByColor`)
+   * @param value Internal packed value
    */
-  get red() {
-    return this.color ? this.color >> 16 & 255 : null;
+  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;
+  }
+  // ---------------------------------------------------------------------
+  // Color method
+  // ---------------------------------------------------------------------
+  /** Gets the current color method. */
+  get colorMethod() {
+    return this._colorMethod;
   }
   /**
-   * Gets the green component of the current color.
+   * Sets the color method.
    *
-   * @returns {number | null} The green component (0-255).
+   * 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() {
-    return this.color ? this.color >> 8 & 255 : null;
+    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 blue component of the current color.
+   * Gets the packed RGB value (0xRRGGBB).
    *
-   * @returns {number | null} The blue component (0-255).
-   */
-  get blue() {
-    return this.color ? this.color & 255 : null;
+   * - 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 n.ByColor:
+      case n.ByBlock:
+      case n.ByLayer:
+        return this._value;
+      case n.ByACI:
+        return this._value ? b.getColorByIndex(this._value) : this._value;
+      default:
+        return;
+    }
   }
   /**
-   * Gets the AutoCAD color index value. The index value will be in the range 0 to 256.
-   * 0 and 256 are special values.
+   * Sets the RGB color.
    *
-   * @returns {number | null} The color index.
+   * @param r Red component (0–255)
+   * @param g Green component (0–255)
+   * @param b Blue component (0–255)
+   * @returns The current instance for chaining
    */
-  get colorIndex() {
-    return this._colorIndex;
+  setRGB(e, t, s) {
+    const o = Math.max(0, Math.min(255, Math.round(e))), i = Math.max(0, Math.min(255, Math.round(t))), a = Math.max(0, Math.min(255, Math.round(s)));
+    return this._value = o << 16 | i << 8 | a, this._colorMethod = n.ByColor, this;
   }
   /**
-   * Sets the AutoCAD color index value. If value less than 0 is set, 0 will be used. If value greater than
-   * 256 is set, 256 will be used.
-   * - 0 indicates that the entity uses the color of the BlockReference that's displaying it. If the entity
-   * is not displayed through a block reference (for example, it is directly owned by the model space
-   * block table record) and its color is 0, then it will display as though its color were 7.
-   * - 256 indicates that the entity uses the color specified in the layer table record it references.
+   * Sets the RGB color by a single packed number (0xRRGGBB).
    *
-   * @param {number | null} value - The color index to set (0-256).
+   * @param value Packed RGB number
    */
-  set colorIndex(e) {
-    e == null ? this._colorIndex = null : (this._colorIndex = w(e, 0, 256), this._colorIndex > 0 && this._colorIndex < 256 ? (this._color = T[e], this._colorName = this.getColorNameByValue(this._color)) : (this._color = null, this._colorName = null));
+  setRGBValue(e) {
+    return e == null || !Number.isFinite(e) ? (console.warn("Invalid RGB value:", e), this) : (this._value = e & 16777215, this._colorMethod = n.ByColor, this);
   }
   /**
-   * Gets the name of the current color.
+   * Sets the RGB color from a CSS color string.
    *
-   * @returns {string | null} The color name.
-   */
-  get colorName() {
-    return this._colorName;
+   * 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
+   */
+  setRGBFromCss(e) {
+    if (!e) return this;
+    const t = e.trim().toLowerCase();
+    if (t.startsWith("#")) {
+      let i = 0, a = 0, c = 0;
+      if (t.length === 7)
+        i = parseInt(t.substr(1, 2), 16), a = parseInt(t.substr(3, 2), 16), c = parseInt(t.substr(5, 2), 16);
+      else if (t.length === 4)
+        i = parseInt(t[1] + t[1], 16), a = 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(i, a, c);
+    }
+    const s = t.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+    if (s) {
+      const i = parseInt(s[1], 10), a = parseInt(s[2], 10), c = parseInt(s[3], 10);
+      return this.setRGB(i, a, c);
+    }
+    const o = b.getColorByName(e);
+    return o !== void 0 ? this.setRGBValue(o) : (console.warn("Unknown CSS color string:", e), this);
   }
   /**
-   * Sets the color by name.
+   * Sets the color as a scalar grayscale value.
    *
-   * @param {string | null} value - The color name to set.
+   * @param scalar Scalar value (0–255)
+   * @returns The current instance for chaining
    */
-  set colorName(e) {
-    if (e) {
-      const t = I[e.toLowerCase()];
-      t !== void 0 ? (this._colorName = e, this._color = t, this._colorIndex = this.getColorIndexByValue(this._color)) : console.warn("Unknown color: " + e);
-    } else
-      this._colorName = null;
+  setScalar(e) {
+    return this.setRGB(e, e, e);
   }
   /**
-   * Checks if the color has a name.
-   *
-   * @returns {boolean} True if the color has no name, false otherwise.
+   * Gets the hexadecimal representation of the color (e.g., "0xFF00FF").
    */
-  get hasColorName() {
-    return this._colorName == null;
+  get hexColor() {
+    const e = this.RGB;
+    return e == null ? void 0 : "0x" + e.toString(16).padStart(6, "0").toUpperCase();
   }
   /**
-   * Checks if the color has an index.
-   *
-   * @returns {boolean} True if the color has no index, false otherwise.
+   * Gets the CSS RGB color string (e.g., "rgb(255,0,255)").
    */
-  get hasColorIndex() {
-    return this._colorIndex == null;
+  get cssColor() {
+    const e = this.RGB;
+    if (e != null)
+      return `rgb(${e >> 16 & 255},${e >> 8 & 255},${e & 255})`;
+  }
+  // ---------------------------------------------------------------------
+  // ACI accessors (ByACI)
+  // ---------------------------------------------------------------------
+  /** Gets the AutoCAD Color Index (ACI), or undefined if not ByACI, ByBlock, or ByLayer. */
+  get colorIndex() {
+    return this._colorMethod === n.ByACI ? this._value : this._colorMethod === n.ByLayer ? 256 : this._colorMethod === n.ByBlock ? 0 : void 0;
   }
   /**
-   * Checks if the color is set to "ByLayer".
+   * 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`
    *
-   * @returns {boolean} True if the color is "ByLayer", false otherwise.
+   * @param index ACI index
    */
-  get isByLayer() {
-    return this.colorIndex == 256;
+  set colorIndex(e) {
+    if (e == null) return;
+    const t = Math.max(0, Math.min(256, Math.round(e)));
+    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);
   }
   /**
-   * Sets the color to "ByLayer".
-   *
-   * @returns {AcCmColor} The current instance.
+   * Returns true if the color method is ByColor (explicit RGB).
    */
-  setByLayer() {
-    return this.colorIndex = 256, this;
+  get isByColor() {
+    return this._colorMethod === n.ByColor;
   }
   /**
-   * Checks if the color is set to "ByBlock".
-   *
-   * @returns {boolean} True if the color is "ByBlock", false otherwise.
+   * Returns true if the color method is ByACI.
    */
-  get isByBlock() {
-    return this.colorIndex == 0;
+  get isByACI() {
+    return this._colorMethod === n.ByACI;
+  }
+  // ---------------------------------------------------------------------
+  // Layer / Block helpers
+  // ---------------------------------------------------------------------
+  /** Returns true if the color method is ByLayer. */
+  get isByLayer() {
+    return this._colorMethod === n.ByLayer;
   }
   /**
-   * Sets the color to "ByBlock".
-   *
-   * @returns {AcCmColor} The current instance.
+   * Sets the color to ByLayer.
+   * @param value - Option layer color value
    */
-  setByBlock() {
-    return this.colorIndex = 0, this;
+  setByLayer(e) {
+    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 === n.ByBlock;
   }
   /**
-   * Sets the color using a scalar value (RGB).
-   *
-   * @param {number} scalar - The scalar value (0-255).
-   * @returns {AcCmColor} The current instance.
+   * Sets the color to ByBlock.
+   * @param value - Option layer color value
    */
-  setScalar(e) {
-    return this.setRGB(e, e, e), this;
+  setByBlock(e) {
+    return this._colorMethod = n.ByBlock, e == null ? this._value = 0 : this._value = e, this;
   }
+  // ---------------------------------------------------------------------
+  // Color name (dynamic)
+  // ---------------------------------------------------------------------
   /**
-   * Sets the color using RGB values.
+   * Gets the color name.
    *
-   * @param {number} r - The red component (0-255).
-   * @param {number} g - The green component (0-255).
-   * @param {number} b - The blue component (0-255).
-   * @returns {AcCmColor} The current instance.
+   * For `ByColor` or `ByACI`, resolves the name via `AcCmColorUtil`.
+   * For `ByLayer` or `ByBlock`, returns the corresponding string.
    */
-  setRGB(e, t, r) {
-    const o = Math.round(w(e, 0, 255)), i = Math.round(w(t, 0, 255)), l = Math.round(w(r, 0, 255));
-    return this.color = (o << 16) + (i << 8) + l, this;
+  get colorName() {
+    switch (this._colorMethod) {
+      case n.ByLayer:
+        return "ByLayer";
+      case n.ByBlock:
+        return "ByBlock";
+      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.
    *
-   * @param {string} style - The color name to set.
-   * @returns {AcCmColor} The current instance.
+   * Resolves the name to an RGB value via `AcCmColorUtil`.
+   *
+   * @param name Color name
    */
-  setColorName(e) {
-    const t = I[e.toLowerCase()];
-    return t !== void 0 ? this.color = t : console.warn("Unknown color " + e), this;
+  set colorName(e) {
+    if (!e) return;
+    const t = b.getColorByName(e);
+    t !== void 0 ? (this._value = t, this._colorMethod = n.ByColor) : console.warn("Unknown color name:", e);
   }
+  // ---------------------------------------------------------------------
+  // Clone / Copy / Equals
+  // ---------------------------------------------------------------------
   /**
-   * Clones the current AcCmColor instance.
+   * Creates a clone of this color instance.
    *
-   * @returns {AcCmColor} A new AcCmColor instance with the same color and index.
+   * @returns A new AcCmColor instance with the same method and value
    */
   clone() {
-    const e = new C();
-    return e.colorIndex = this.colorIndex, e.color = this.color, e._colorName = this._colorName, this;
+    const e = new B();
+    return e._colorMethod = this._colorMethod, e._value = this._value, e;
   }
   /**
-   * Copies the color from another AcCmColor instance.
+   * Copies color values from another AcCmColor instance.
    *
-   * @param {AcCmColor} color - The color to copy from.
-   * @returns {AcCmColor} The current instance.
+   * @param other The source color
+   * @returns The current instance
    */
   copy(e) {
-    return this.colorIndex = e.colorIndex, this.color = e.color, this._colorName = e._colorName, this;
+    return this._colorMethod = e._colorMethod, this._value = e._value, this;
   }
   /**
-   * Checks if two AcCmColor instances are equal.
+   * Checks equality with another color.
    *
-   * @param {AcCmColor} c - The color to compare with.
-   * @returns {boolean} True if the colors and their indices are the same.
+   * @param other The color to compare
+   * @returns True if color method and value are identical
    */
   equals(e) {
-    return e.color == this.color && e.colorIndex == this.colorIndex && e._colorName == this._colorName;
+    return this._colorMethod === e._colorMethod && this._value === e._value;
   }
+  // ---------------------------------------------------------------------
+  // String representation
+  // ---------------------------------------------------------------------
   /**
    * Returns a string representation of the color.
    *
-   * @returns {string} The color name or hexadecimal string.
+   * - "ByLayer" for ByLayer colors
+   * - "ByBlock" for ByBlock colors
+   * - One number for color index
+   * - Three comma-separated numbers for RGB color
    */
   toString() {
-    return this.isByLayer ? "ByLayer" : this.isByBlock ? "ByBlock" : this.colorName ? this.colorName : this.hexColor;
+    switch (this._colorMethod) {
+      case n.ByLayer:
+        return "ByLayer";
+      case n.ByBlock:
+        return "ByBlock";
+      case n.ByACI:
+        return this._value !== void 0 ? String(this._value) : "";
+      case n.ByColor:
+        return this._value ? `${this.red},${this.green},${this.blue}` : "";
+      default:
+        return "";
+    }
   }
   /**
-   * Finds the color name associated with a given RGB value.
+   * Creates one AcCmColor from one string
+   */
+  static fromString(e) {
+    if (!e) return;
+    const t = e.trim();
+    if (/^bylayer$/i.test(t))
+      return new B(n.ByLayer);
+    if (/^byblock$/i.test(t))
+      return new B(n.ByBlock);
+    if (/^\d{1,3},\d{1,3},\d{1,3}$/i.test(t)) {
+      const [o, i, a] = t.split(",").map(Number), c = new B(n.ByColor);
+      return c.setRGB(o, i, a), c;
+    }
+    if (/^\d+$/.test(t)) {
+      const o = parseInt(t, 10);
+      return new B(n.ByACI, o);
+    }
+    const s = b.getColorByName(t);
+    if (s != null)
+      return new B(n.ByColor, s);
+    console.warn("Unknown color name:", e);
+  }
+}
+class oe {
+  /**
+   * Constructs a new `AcCmEntityColor`.
    *
-   * @private
-   * @param {number} target - The RGB value to find a name for.
-   * @returns {string | null} The color name if found, null otherwise.
+   * @param method Initial color method (defaults to `ByColor`)
+   * @param value Internal packed value (defaults to `0`)
    */
-  getColorNameByValue(e) {
-    for (const [t, r] of Object.entries(I))
-      if (r === e)
-        return t;
-    return null;
+  constructor(e = n.ByColor, t = 0) {
+    this._colorMethod = e, this._value = t;
   }
   /**
-   * Finds the AutoCAD color index associated with a given RGB value.
+   * 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 = 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 = 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 = n.ByColor, this._value = this._value & 16776960 | e & 255;
+  }
+  /**
+   * Sets all RGB components.
    *
-   * @private
-   * @param {number} target - The RGB value to find an index for.
-   * @returns {number | null} The color index if found, null otherwise.
-   */
-  getColorIndexByValue(e) {
-    const t = T.length - 1;
-    for (let r = 1; r < t; ++r)
-      if (T[r] === e)
-        return r;
-    return null;
+   * @param r Red (0–255)
+   * @param g Green (0–255)
+   * @param b Blue (0–255)
+   */
+  setRGB(e, t, s) {
+    this._colorMethod = n.ByColor, this._value = (e & 255) << 16 | (t & 255) << 8 | s & 255;
   }
-};
-C.NAMES = I;
-let R = C;
-const te = {
+  // ---------------------------------------------------------------------
+  // ACI accessors
+  // ---------------------------------------------------------------------
+  /**
+   * Gets the AutoCAD Color Index (ACI). Only valid when colorMethod = ByACI.
+   */
+  get colorIndex() {
+    return this._value;
+  }
+  /**
+   * Sets the AutoCAD Color Index (ACI).
+   */
+  set colorIndex(e) {
+    this._colorMethod = n.ByACI, this._value = e;
+  }
+  // ---------------------------------------------------------------------
+  // Layer index accessors
+  // ---------------------------------------------------------------------
+  /**
+   * Gets the referenced layer index. Only valid when colorMethod = ByLayer.
+   */
+  get layerIndex() {
+    return this._value;
+  }
+  /**
+   * Sets the layer index for ByLayer color mode.
+   */
+  set layerIndex(e) {
+    this._colorMethod = n.ByLayer, this._value = e;
+  }
+  // ---------------------------------------------------------------------
+  // Utility methods
+  // ---------------------------------------------------------------------
+  /**
+   * Returns true if the color method is ByColor (explicit RGB).
+   */
+  isByColor() {
+    return this._colorMethod === n.ByColor;
+  }
+  /**
+   * Returns true if the color method is ByLayer.
+   */
+  isByLayer() {
+    return this._colorMethod === n.ByLayer;
+  }
+  /**
+   * Returns true if the color method is ByBlock.
+   */
+  isByBlock() {
+    return this._colorMethod === n.ByBlock;
+  }
+  /**
+   * Returns true if the color method is ByACI.
+   */
+  isByACI() {
+    return this._colorMethod === n.ByACI;
+  }
+  /**
+   * Returns true if color is uninitialized or invalid.
+   */
+  isNone() {
+    return this._colorMethod === n.None;
+  }
+  /**
+   * Gets the packed internal value.
+   *
+   * - RGB → packed 24-bit integer
+   * - ACI → index
+   * - Layer → index
+   */
+  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
    */
@@ -713,7 +991,7 @@ const te = {
     return new Error("Not implemented yet");
   }
 };
-class re {
+class ie {
   /**
    * Creates {@link AcCmEventDispatcher} object.
    */
@@ -722,13 +1000,13 @@ class re {
   }
   addEventListener(e, t) {
     this._listeners === void 0 && (this._listeners = {});
-    const r = this._listeners;
-    r[e] === void 0 && (r[e] = []), r[e].indexOf(t) === -1 && r[e].push(t);
+    const s = this._listeners;
+    s[e] === void 0 && (s[e] = []), s[e].indexOf(t) === -1 && s[e].push(t);
   }
   hasEventListener(e, t) {
     if (this._listeners === void 0) return !1;
-    const r = this._listeners;
-    return r[e] !== void 0 && r[e].indexOf(t) !== -1;
+    const s = this._listeners;
+    return s[e] !== void 0 && s[e].indexOf(t) !== -1;
   }
   removeEventListener(e, t) {
     if (this._listeners === void 0) return;
@@ -744,16 +1022,16 @@ class re {
    */
   dispatchEvent(e) {
     if (this._listeners === void 0) return;
-    const r = this._listeners[e.type];
-    if (r !== void 0) {
+    const s = this._listeners[e.type];
+    if (s !== void 0) {
       e.target = this;
-      const o = r.slice(0);
-      for (let i = 0, l = o.length; i < l; i++)
+      const o = s.slice(0);
+      for (let i = 0, a = o.length; i < a; i++)
         o[i].call(this, e);
     }
   }
 }
-class U {
+class D {
   constructor() {
     this.listeners = [];
   }
@@ -783,223 +1061,237 @@ class U {
    * @param payload Input payload passed to listener
    */
   dispatch(e, ...t) {
-    for (const r of this.listeners)
-      r.call(null, e, ...t);
+    for (const s of this.listeners)
+      s.call(null, e, ...t);
   }
 }
-var K = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
-function z(n) {
-  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+function C(r) {
+  return r === null || typeof r != "object" ? r : Array.isArray(r) ? [...r] : { ...r };
+}
+function F(r) {
+  if (r === null || typeof r != "object")
+    return r;
+  if (r instanceof Date)
+    return new Date(r.getTime());
+  if (r instanceof RegExp)
+    return new RegExp(r.source, r.flags);
+  if (Array.isArray(r))
+    return r.map(F);
+  const e = {};
+  for (const t in r)
+    Object.prototype.hasOwnProperty.call(r, t) && (e[t] = F(r[t]));
+  return e;
+}
+function Y(r, ...e) {
+  for (const t of e)
+    if (t)
+      for (const s in t)
+        Object.prototype.hasOwnProperty.call(t, s) && r[s] === void 0 && (r[s] = t[s]);
+  return r;
+}
+function Z(r, e) {
+  return r != null && Object.prototype.hasOwnProperty.call(r, e);
+}
+function J(r) {
+  return r == null ? !0 : Array.isArray(r) || typeof r == "string" ? r.length === 0 : r instanceof Map || r instanceof Set ? r.size === 0 : typeof r == "object" ? Object.keys(r).length === 0 : !1;
+}
+function M(r, e) {
+  if (r === e)
+    return !0;
+  if (r == null || e == null)
+    return r === e;
+  if (typeof r != typeof e)
+    return !1;
+  if (typeof r != "object")
+    return r === e;
+  if (Array.isArray(r) !== Array.isArray(e))
+    return !1;
+  if (Array.isArray(r)) {
+    if (r.length !== e.length)
+      return !1;
+    for (let o = 0; o < r.length; o++)
+      if (!M(r[o], e[o]))
+        return !1;
+    return !0;
+  }
+  const t = Object.keys(r), s = Object.keys(e);
+  if (t.length !== s.length)
+    return !1;
+  for (const o of t)
+    if (!Object.prototype.hasOwnProperty.call(
+      e,
+      o
+    ) || !M(
+      r[o],
+      e[o]
+    ))
+      return !1;
+  return !0;
+}
+var X = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function Q(r) {
+  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
 }
 var q = { exports: {} };
-(function(n) {
+(function(r) {
   (function(e, t) {
-    n.exports ? n.exports = t() : e.log = t();
-  })(K, function() {
+    r.exports ? r.exports = t() : e.log = t();
+  })(X, function() {
     var e = function() {
-    }, t = "undefined", r = typeof window !== t && typeof window.navigator !== t && /Trident\/|MSIE /.test(window.navigator.userAgent), o = [
+    }, t = "undefined", s = typeof window !== t && typeof window.navigator !== t && /Trident\/|MSIE /.test(window.navigator.userAgent), o = [
       "trace",
       "debug",
       "info",
       "warn",
       "error"
-    ], i = {}, l = null;
-    function g(a, h) {
-      var s = a[h];
-      if (typeof s.bind == "function")
-        return s.bind(a);
+    ], i = {}, a = null;
+    function c(h, d) {
+      var l = h[d];
+      if (typeof l.bind == "function")
+        return l.bind(h);
       try {
-        return Function.prototype.bind.call(s, a);
+        return Function.prototype.bind.call(l, h);
       } catch {
         return function() {
-          return Function.prototype.apply.apply(s, [a, arguments]);
+          return Function.prototype.apply.apply(l, [h, arguments]);
         };
       }
     }
-    function L() {
+    function I() {
       console.log && (console.log.apply ? console.log.apply(console, arguments) : Function.prototype.apply.apply(console.log, [console, arguments])), console.trace && console.trace();
     }
-    function y(a) {
-      return a === "debug" && (a = "log"), typeof console === t ? !1 : a === "trace" && r ? L : console[a] !== void 0 ? g(console, a) : console.log !== void 0 ? g(console, "log") : e;
+    function m(h) {
+      return h === "debug" && (h = "log"), typeof console === t ? !1 : h === "trace" && s ? I : console[h] !== void 0 ? c(console, h) : console.log !== void 0 ? c(console, "log") : e;
     }
-    function p() {
-      for (var a = this.getLevel(), h = 0; h < o.length; h++) {
-        var s = o[h];
-        this[s] = h < a ? e : this.methodFactory(s, a, this.name);
+    function _() {
+      for (var h = this.getLevel(), d = 0; d < o.length; d++) {
+        var l = o[d];
+        this[l] = d < h ? e : this.methodFactory(l, h, this.name);
       }
-      if (this.log = this.debug, typeof console === t && a < this.levels.SILENT)
+      if (this.log = this.debug, typeof console === t && h < this.levels.SILENT)
         return "No console available for logging";
     }
-    function O(a) {
+    function x(h) {
       return function() {
-        typeof console !== t && (p.call(this), this[a].apply(this, arguments));
+        typeof console !== t && (_.call(this), this[h].apply(this, arguments));
       };
     }
-    function d(a, h, s) {
-      return y(a) || O.apply(this, arguments);
+    function f(h, d, l) {
+      return m(h) || x.apply(this, arguments);
     }
-    function M(a, h) {
-      var s = this, E, N, m, f = "loglevel";
-      typeof a == "string" ? f += ":" + a : typeof a == "symbol" && (f = void 0);
-      function V(c) {
-        var u = (o[c] || "silent").toUpperCase();
-        if (!(typeof window === t || !f)) {
+    function S(h, d) {
+      var l = this, E, R, w, p = "loglevel";
+      typeof h == "string" ? p += ":" + h : typeof h == "symbol" && (p = void 0);
+      function z(u) {
+        var g = (o[u] || "silent").toUpperCase();
+        if (!(typeof window === t || !p)) {
           try {
-            window.localStorage[f] = u;
+            window.localStorage[p] = g;
             return;
           } catch {
           }
           try {
-            window.document.cookie = encodeURIComponent(f) + "=" + u + ";";
+            window.document.cookie = encodeURIComponent(p) + "=" + g + ";";
           } catch {
           }
         }
       }
-      function B() {
-        var c;
-        if (!(typeof window === t || !f)) {
+      function P() {
+        var u;
+        if (!(typeof window === t || !p)) {
           try {
-            c = window.localStorage[f];
+            u = window.localStorage[p];
           } catch {
           }
-          if (typeof c === t)
+          if (typeof u === t)
             try {
-              var u = window.document.cookie, k = encodeURIComponent(f), S = u.indexOf(k + "=");
-              S !== -1 && (c = /^([^;]+)/.exec(
-                u.slice(S + k.length + 1)
+              var g = window.document.cookie, A = encodeURIComponent(p), U = g.indexOf(A + "=");
+              U !== -1 && (u = /^([^;]+)/.exec(
+                g.slice(U + A.length + 1)
               )[1]);
             } catch {
             }
-          return s.levels[c] === void 0 && (c = void 0), c;
+          return l.levels[u] === void 0 && (u = void 0), u;
         }
       }
-      function $() {
-        if (!(typeof window === t || !f)) {
+      function H() {
+        if (!(typeof window === t || !p)) {
           try {
-            window.localStorage.removeItem(f);
+            window.localStorage.removeItem(p);
           } catch {
           }
           try {
-            window.document.cookie = encodeURIComponent(f) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+            window.document.cookie = encodeURIComponent(p) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
           } catch {
           }
         }
       }
-      function v(c) {
-        var u = c;
-        if (typeof u == "string" && s.levels[u.toUpperCase()] !== void 0 && (u = s.levels[u.toUpperCase()]), typeof u == "number" && u >= 0 && u <= s.levels.SILENT)
-          return u;
-        throw new TypeError("log.setLevel() called with invalid level: " + c);
+      function L(u) {
+        var g = u;
+        if (typeof g == "string" && l.levels[g.toUpperCase()] !== void 0 && (g = l.levels[g.toUpperCase()]), typeof g == "number" && g >= 0 && g <= l.levels.SILENT)
+          return g;
+        throw new TypeError("log.setLevel() called with invalid level: " + u);
       }
-      s.name = a, s.levels = {
+      l.name = h, l.levels = {
         TRACE: 0,
         DEBUG: 1,
         INFO: 2,
         WARN: 3,
         ERROR: 4,
         SILENT: 5
-      }, s.methodFactory = h || d, s.getLevel = function() {
-        return m ?? N ?? E;
-      }, s.setLevel = function(c, u) {
-        return m = v(c), u !== !1 && V(m), p.call(s);
-      }, s.setDefaultLevel = function(c) {
-        N = v(c), B() || s.setLevel(c, !1);
-      }, s.resetLevel = function() {
-        m = null, $(), p.call(s);
-      }, s.enableAll = function(c) {
-        s.setLevel(s.levels.TRACE, c);
-      }, s.disableAll = function(c) {
-        s.setLevel(s.levels.SILENT, c);
-      }, s.rebuild = function() {
-        if (l !== s && (E = v(l.getLevel())), p.call(s), l === s)
-          for (var c in i)
-            i[c].rebuild();
-      }, E = v(
-        l ? l.getLevel() : "WARN"
+      }, l.methodFactory = d || f, l.getLevel = function() {
+        return w ?? R ?? E;
+      }, l.setLevel = function(u, g) {
+        return w = L(u), g !== !1 && z(w), _.call(l);
+      }, l.setDefaultLevel = function(u) {
+        R = L(u), P() || l.setLevel(u, !1);
+      }, l.resetLevel = function() {
+        w = null, H(), _.call(l);
+      }, l.enableAll = function(u) {
+        l.setLevel(l.levels.TRACE, u);
+      }, l.disableAll = function(u) {
+        l.setLevel(l.levels.SILENT, u);
+      }, l.rebuild = function() {
+        if (a !== l && (E = L(a.getLevel())), _.call(l), a === l)
+          for (var u in i)
+            i[u].rebuild();
+      }, E = L(
+        a ? a.getLevel() : "WARN"
       );
-      var P = B();
-      P != null && (m = v(P)), p.call(s);
+      var T = P();
+      T != null && (w = L(T)), _.call(l);
     }
-    l = new M(), l.getLogger = function(h) {
-      if (typeof h != "symbol" && typeof h != "string" || h === "")
+    a = new S(), a.getLogger = function(d) {
+      if (typeof d != "symbol" && typeof d != "string" || d === "")
         throw new TypeError("You must supply a name when creating a logger.");
-      var s = i[h];
-      return s || (s = i[h] = new M(
-        h,
-        l.methodFactory
-      )), s;
+      var l = i[d];
+      return l || (l = i[d] = new S(
+        d,
+        a.methodFactory
+      )), l;
     };
     var j = typeof window !== t ? window.log : void 0;
-    return l.noConflict = function() {
-      return typeof window !== t && window.log === l && (window.log = j), l;
-    }, l.getLoggers = function() {
+    return a.noConflict = function() {
+      return typeof window !== t && window.log === a && (window.log = j), a;
+    }, a.getLoggers = function() {
       return i;
-    }, l.default = l, l;
+    }, a.default = a, a;
   });
 })(q);
-var D = q.exports;
-const W = /* @__PURE__ */ z(D), Y = /* @__PURE__ */ H({
+var $ = q.exports;
+const ee = /* @__PURE__ */ Q($), te = /* @__PURE__ */ W({
   __proto__: null,
-  default: W
-}, [D]), ne = !0, x = Y;
-x.setLevel("debug");
-const oe = (n) => {
+  default: ee
+}, [$]), le = !0, O = te;
+O.setLevel("debug");
+const ae = (r) => {
   try {
-    x.setLevel(n);
+    O.setLevel(r);
   } catch (e) {
-    x.setLevel("error"), x.error(e);
+    O.setLevel("error"), O.error(e);
   }
 };
-function A(n) {
-  return n === null || typeof n != "object" ? n : Array.isArray(n) ? [...n] : { ...n };
-}
-function Z(n, ...e) {
-  for (const t of e)
-    if (t)
-      for (const r in t)
-        Object.prototype.hasOwnProperty.call(t, r) && n[r] === void 0 && (n[r] = t[r]);
-  return n;
-}
-function J(n, e) {
-  return n != null && Object.prototype.hasOwnProperty.call(n, e);
-}
-function X(n) {
-  return n == null ? !0 : Array.isArray(n) || typeof n == "string" ? n.length === 0 : n instanceof Map || n instanceof Set ? n.size === 0 : typeof n == "object" ? Object.keys(n).length === 0 : !1;
-}
-function _(n, e) {
-  if (n === e)
-    return !0;
-  if (n == null || e == null)
-    return n === e;
-  if (typeof n != typeof e)
-    return !1;
-  if (typeof n != "object")
-    return n === e;
-  if (Array.isArray(n) !== Array.isArray(e))
-    return !1;
-  if (Array.isArray(n)) {
-    if (n.length !== e.length)
-      return !1;
-    for (let o = 0; o < n.length; o++)
-      if (!_(n[o], e[o]))
-        return !1;
-    return !0;
-  }
-  const t = Object.keys(n), r = Object.keys(e);
-  if (t.length !== r.length)
-    return !1;
-  for (const o of t)
-    if (!Object.prototype.hasOwnProperty.call(
-      e,
-      o
-    ) || !_(
-      n[o],
-      e[o]
-    ))
-      return !1;
-  return !0;
-}
-class F {
+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
@@ -1008,11 +1300,11 @@ class F {
    */
   constructor(e, t) {
     this.events = {
-      attrChanged: new U(),
-      modelChanged: new U()
+      attrChanged: new D(),
+      modelChanged: new D()
     }, this._changing = !1, this._previousAttributes = {}, this._pending = !1;
-    const r = e || {};
-    t && Z(r, t), this.attributes = r, this.changed = {};
+    const s = e || {};
+    t && Y(s, t), this.attributes = s, this.changed = {};
   }
   /**
    * Gets the value of an attribute.
@@ -1043,31 +1335,31 @@ class F {
   get(e) {
     return this.attributes[e];
   }
-  set(e, t, r) {
+  set(e, t, s) {
     if (e == null) return this;
     let o;
-    typeof e == "object" ? (o = e, r = t) : (o = {}, o[e] = t), r || (r = {});
-    const i = r.unset, l = r.silent, g = [], L = this._changing;
-    this._changing = !0, L || (this._previousAttributes = A(this.attributes), this.changed = {});
-    const y = this.attributes, p = this.changed, O = this._previousAttributes;
-    for (const d in o)
-      t = o[d], _(y[d], t) || g.push(d), _(O[d], t) ? delete p[d] : p[d] = t, i ? delete y[d] : y[d] = t;
-    if (!l) {
-      g.length && (this._pending = r);
-      for (let d = 0; d < g.length; d++)
+    typeof e == "object" ? (o = e, s = t) : (o = {}, o[e] = t), s || (s = {});
+    const i = s.unset, a = s.silent, c = [], I = this._changing;
+    this._changing = !0, I || (this._previousAttributes = C(this.attributes), this.changed = {});
+    const m = this.attributes, _ = this.changed, x = this._previousAttributes;
+    for (const f in o)
+      t = o[f], M(m[f], t) || c.push(f), M(x[f], t) ? delete _[f] : _[f] = t, i ? delete m[f] : m[f] = t;
+    if (!a) {
+      c.length && (this._pending = s);
+      for (let f = 0; f < c.length; f++)
         this.events.attrChanged.dispatch({
           object: this,
-          attrName: g[d],
-          attrValue: y[g[d]],
-          options: r
+          attrName: c[f],
+          attrValue: m[c[f]],
+          options: s
         });
     }
-    if (L) return this;
-    if (!l)
+    if (I) return this;
+    if (!a)
       for (; this._pending; )
-        r = this._pending, this._pending = !1, this.events.modelChanged.dispatch({
+        s = this._pending, this._pending = !1, this.events.modelChanged.dispatch({
           object: this,
-          options: r
+          options: s
         });
     return this._pending = !1, this._changing = !1, this;
   }
@@ -1079,7 +1371,7 @@ class F {
    * If you specify an attribute name, determine if that attribute has changed.
    */
   hasChanged(e) {
-    return e == null ? !X(this.changed) : J(this.changed, 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
@@ -1089,13 +1381,13 @@ class F {
    * the model, determining if there *would be* a change.
    */
   changedAttributes(e) {
-    if (!e) return this.hasChanged() ? A(this.changed) : {};
-    const t = this._changing ? this._previousAttributes : this.attributes, r = {};
+    if (!e) return this.hasChanged() ? C(this.changed) : {};
+    const t = this._changing ? this._previousAttributes : this.attributes, s = {};
     for (const o in e) {
       const i = e[o];
-      _(t[o], i) || (r[o] = i);
+      M(t[o], i) || (s[o] = i);
     }
-    return r;
+    return s;
   }
   /**
    * Get the previous value of an attribute, recorded at the time the last `"change"` event was fired.
@@ -1107,17 +1399,17 @@ class F {
    * Get all of the attributes of the model at the time of the previous `"change"` event.
    */
   previousAttributes() {
-    return A(this._previousAttributes);
+    return C(this._previousAttributes);
   }
   /**
    * Create a new model with identical attributes to this one.
    */
   clone() {
-    const e = A(this.attributes);
-    return new F(e);
+    const e = C(this.attributes);
+    return new V(e);
   }
 }
-class b {
+class k {
   /**
    * Private constructor to enforce singleton pattern.
    */
@@ -1129,7 +1421,7 @@ class b {
    * @returns The shared AcCmPerformanceCollector instance.
    */
   static getInstance() {
-    return b.instance || (b.instance = new b()), b.instance;
+    return k.instance || (k.instance = new k()), k.instance;
   }
   /**
    * Adds or replaces a performance entry by name.
@@ -1176,7 +1468,7 @@ class b {
     return this.entries.delete(e);
   }
 }
-class se {
+class he {
   /**
    * Converts a byte count to a human-readable string using appropriate size units.
    *
@@ -1201,11 +1493,253 @@ class se {
    */
   static formatBytes(e, t = 2) {
     if (e === 0) return "0 B";
-    const r = 1024, o = Math.max(0, t), i = ["B", "KB", "MB", "GB", "TB"], l = Math.floor(Math.log(e) / Math.log(r)), g = e / Math.pow(r, l);
-    return `${parseFloat(g.toFixed(o))} ${i[l]}`;
+    const s = 1024, o = Math.max(0, t), i = ["B", "KB", "MB", "GB", "TB"], a = Math.floor(Math.log(e) / Math.log(s)), c = e / Math.pow(s, a);
+    return `${parseFloat(c.toFixed(o))} ${i[a]}`;
   }
 }
-class ie {
+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 v {
+  /**
+   * Creates a new transparency object.
+   *
+   * @param alpha
+   *   When provided, constructs with `ByAlpha` method and sets alpha.
+   *   Must be between 0 and 255.
+   */
+  constructor(e) {
+    e !== void 0 ? (this._method = y.ByAlpha, this._alpha = v.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 = v.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
+   */
+  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 v();
+    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 i = new v();
+      return i._method = y.ByLayer, i;
+    }
+    if (/^byblock$/i.test(t)) {
+      const i = new v();
+      return i._method = y.ByBlock, i;
+    }
+    const s = Number(t);
+    if (Number.isInteger(s) && s >= 0 && s <= 255)
+      return new v(s);
+    const o = new v();
+    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, i = new v();
+    return i._method = o, i._alpha = v.clampAlpha(s), i;
+  }
+}
+class ue {
   /**
    * Creates a new task with the specified name.
    *
@@ -1228,7 +1762,7 @@ class ie {
     throw new Error("run() must be implemented by subclass");
   }
 }
-class le {
+class ce {
   constructor() {
     this.tasks = [], this.onProgress = () => {
     }, this.onComplete = () => {
@@ -1244,9 +1778,9 @@ class le {
    * @returns Promise that resolves with the result of the callback
    */
   scheduleTask(e) {
-    return new Promise((t, r) => {
+    return new Promise((t, s) => {
       const o = () => {
-        Promise.resolve(e()).then(t).catch(r);
+        Promise.resolve(e()).then(t).catch(s);
       };
       typeof window < "u" && typeof window.requestAnimationFrame == "function" ? window.requestAnimationFrame(o) : setTimeout(o, 0);
     });
@@ -1282,31 +1816,31 @@ class le {
    */
   async run(e) {
     const t = this.tasks.length;
-    let r = e;
+    let s = e;
     for (let o = 0; o < t; o++) {
       const i = this.tasks[o];
       try {
-        r = await this.scheduleTask(async () => {
-          const l = await i.run(r);
-          return this.onProgress((o + 1) / t, i), l;
+        s = await this.scheduleTask(async () => {
+          const a = await i.run(s);
+          return this.onProgress((o + 1) / t, i), a;
         });
-      } catch (l) {
-        if (this.onError({ error: l, taskIndex: o, task: i }))
+      } catch (a) {
+        if (this.onError({ error: a, taskIndex: o, task: i }))
           break;
       }
     }
-    this.onComplete(r);
+    this.onComplete(s);
   }
 }
-class Q {
+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, r) {
-    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 = r;
+  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.
@@ -1374,7 +1908,7 @@ class Q {
    * @returns Return the registered loader for the given file path.
    */
   getHandler(e) {
-    for (let t = 0, r = this.handlers.length; t < r; t += 2) {
+    for (let t = 0, s = this.handlers.length; t < s; t += 2) {
       const o = this.handlers[t], i = this.handlers[t + 1];
       if (o.global && (o.lastIndex = 0), o.test(e))
         return i;
@@ -1382,14 +1916,14 @@ class Q {
     return null;
   }
 }
-const ee = /* @__PURE__ */ new Q();
-class ae {
+const se = /* @__PURE__ */ 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 : ee, this.crossOrigin = "anonymous", this.withCredentials = !1, this.path = "", this.resourcePath = "", this.requestHeader = {};
+    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.
@@ -1400,8 +1934,8 @@ class ae {
    * @returns Return a promise.
    */
   loadAsync(e, t) {
-    return new Promise((r, o) => {
-      this.load(e, r, t, o);
+    return new Promise((s, o) => {
+      this.load(e, s, t, o);
     });
   }
   /**
@@ -1455,24 +1989,30 @@ class ae {
   }
 }
 export {
-  R as AcCmColor,
-  te as AcCmErrors,
-  re as AcCmEventDispatcher,
-  U as AcCmEventManager,
-  ae as AcCmLoader,
-  Q as AcCmLoadingManager,
-  F as AcCmObject,
-  b as AcCmPerformanceCollector,
-  ie as AcCmTask,
-  le as AcCmTaskScheduler,
-  se as AcTrStringUtil,
-  ne as DEBUG_MODE,
-  ee as DefaultLoadingManager,
-  A as clone,
-  Z as defaults,
-  J as has,
-  X as isEmpty,
-  _ as isEqual,
-  x as log,
-  oe as setLogLevel
+  B as AcCmColor,
+  n as AcCmColorMethod,
+  b as AcCmColorUtil,
+  oe as AcCmEntityColor,
+  ne as AcCmErrors,
+  ie as AcCmEventDispatcher,
+  D as AcCmEventManager,
+  de as AcCmLoader,
+  re as AcCmLoadingManager,
+  V as AcCmObject,
+  k as AcCmPerformanceCollector,
+  ue as AcCmTask,
+  ce as AcCmTaskScheduler,
+  v as AcCmTransparency,
+  y as AcCmTransparencyMethod,
+  he as AcTrStringUtil,
+  le as DEBUG_MODE,
+  se as DefaultLoadingManager,
+  C as clone,
+  F as deepClone,
+  Y as defaults,
+  Z as has,
+  J as isEmpty,
+  M as isEqual,
+  O as log,
+  ae as setLogLevel
 };