@mlightcad/cad-simple-viewer 1.0.0 → 1.0.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { AcCmEventManager as m, AcGePoint2d as u, AcGeBox2d as N, AcCmColor as k, AcGeBox3d as $, AcDbDatabase as J, AcDbFileType as G, acdbHostApplicationServices as W, AcDbViewport as K, AcDbRasterImage as Z, AcDbRay as Q, AcDbXline as tt, AcDbHatch as j, AcGePolyline2d as et, AcDbLine as st, AcDbTextStyleTableRecord as it, AcDbMText as nt, AcGiMTextAttachmentPoint as ot, AcGePoint3d as rt, AcGeLoop2d as at, AcGeCircArc2d as ct, AcGeMathUtil as T, AcGeLine2d as ht, AcDbArc as lt, AcGeLine3d as M } from "@mlightcad/data-model";
+import { AcCmEventManager as m, AcGePoint2d as u, AcGeBox2d as N, AcCmColor as k, AcGeBox3d as $, AcDbDatabase as J, AcDbFileType as G, acdbHostApplicationServices as W, AcDbViewport as K, AcDbRasterImage as Z, AcDbRay as Q, AcDbXline as tt, AcDbHatch as j, AcGePolyline2d as et, AcDbLine as st, AcDbTextStyleTableRecord as it, AcDbMText as nt, AcGiMTextAttachmentPoint as ot, AcGePoint3d as rt, AcGeLoop2d as at, AcGeCircArc2d as ct, AcGeMathUtil as T, AcGeLine2d as ht, AcDbArc as lt, AcGeLine3d as L } from "@mlightcad/data-model";
 import { AcSvgRenderer as dt } from "@mlightcad/svg-renderer";
 import { find as ut, findIndex as mt, defaults as _t } from "lodash-es";
 import { AcTrBaseView as wt, AcTrBatchedGroup as pt, AcTrRenderer as ft, AcTrViewportView as yt } from "@mlightcad/three-renderer";
@@ -7,9 +7,16 @@ import vt from "three/examples/jsm/libs/stats.module";
 import { AxesGizmo as gt, ObjectPosition as xt } from "@mlightcad/three-viewcube";
 class bt {
   /**
-   * Construct one context to bind one drawing database with its viewer
-   * @param view Input the view used to show the specified drawing
-   * @param doc Input the document associated with the drawing database
+   * Creates a new application context that binds a document with its view.
+   * 
+   * The constructor sets up event listeners to synchronize the document and view:
+   * - Entity additions/modifications are reflected in the view
+   * - Layer visibility changes update the view
+   * - System variable changes (like point display mode) update rendering
+   * - Entity selections show/hide grip points
+   * 
+   * @param view - The view used to display the drawing
+   * @param doc - The document containing the drawing database
    */
   constructor(t, e) {
     this._view = t, this._doc = e, e.database.events.entityAppended.addEventListener((s) => {
@@ -26,49 +33,122 @@ class bt {
       t.unhighlight(s.ids);
     });
   }
+  /**
+   * Gets the view component that renders the CAD drawing.
+   * 
+   * @returns The associated view instance
+   */
   get view() {
     return this._view;
   }
+  /**
+   * Gets the document containing the CAD database.
+   * 
+   * @returns The associated document instance
+   */
   get doc() {
     return this._doc;
   }
 }
 class x {
+  /**
+   * Creates a new command instance.
+   * 
+   * Initializes the command with empty names. Subclasses should set
+   * appropriate global and local names in their constructors.
+   */
   constructor() {
     this.events = {
+      /** Fired just before the command starts executing */
       commandWillStart: new m(),
+      /** Fired after the command finishes executing */
       commandEnded: new m()
     }, this._globalName = "", this._localName = "";
   }
   /**
-   * The global or untranslated name associated with the command.
+   * Gets the global (untranslated) name of the command.
+   * 
+   * The global name is typically used for programmatic access and
+   * should remain consistent across different language localizations.
+   * 
+   * @returns The global command name
    */
   get globalName() {
     return this._globalName;
   }
+  /**
+   * Sets the global (untranslated) name of the command.
+   * 
+   * @param value - The global command name (e.g., 'LINE', 'CIRCLE', 'ZOOM')
+   */
   set globalName(t) {
     this._globalName = t;
   }
   /**
-   * The local or translated name associated with the command.
+   * Gets the local (translated) name of the command.
+   * 
+   * The local name is displayed to users and should be localized
+   * to the current language/region.
+   * 
+   * @returns The localized command name
    */
   get localName() {
     return this._localName;
   }
+  /**
+   * Sets the local (translated) name of the command.
+   * 
+   * @param value - The localized command name (e.g., 'Draw Line', 'Zoom In')
+   */
   set localName(t) {
     this._localName = t;
   }
   /**
-   * Trigger this command. The children class should not override this method to keep event notification
-   * work correctly.
-   * @param context Input current context to execute this command.
+   * Triggers the command execution with proper event handling.
+   * 
+   * This method should not be overridden by subclasses as it handles
+   * the event notification workflow. Subclasses should implement the
+   * `execute()` method instead.
+   * 
+   * The execution flow:
+   * 1. Fires `commandWillStart` event
+   * 2. Calls the `execute()` method
+   * 3. Fires `commandEnded` event
+   * 
+   * @param context - The current application context containing view and document
+   * 
+   * @example
+   * ```typescript
+   * const command = new MyCommand();
+   * command.trigger(docManager.context);
+   * ```
    */
   tirgger(t) {
     this.events.commandWillStart.dispatch({ command: this }), this.execute(t), this.events.commandEnded.dispatch({ command: this });
   }
   /**
-   * Execute this command. The children class should override this method to add business logic of this command.
-   * @param _context Input current context to execute this command.
+   * Executes the command logic.
+   * 
+   * This abstract method must be implemented by subclasses to define
+   * the specific behavior of the command. The method receives the current
+   * application context providing access to the view and document.
+   * 
+   * @param _context - The current application context
+   * 
+   * @example
+   * ```typescript
+   * execute(context: AcApContext) {
+   *   const view = context.view;
+   *   const doc = context.doc;
+   *   
+   *   // Get user input
+   *   const point = await view.editor.getPoint();
+   *   
+   *   // Create entity in document
+   *   const entity = new SomeEntity(point);
+   *   doc.database.addEntity(entity);
+   * }
+   * ```
    */
   execute(t) {
   }
@@ -116,6 +196,10 @@ class St {
   }
 }
 const p = class p {
+  /**
+   * Private constructor to enforce singleton pattern.
+   * Initializes the command stack with system and default command groups.
+   */
   constructor() {
     this._commandsByGroup = [], this._systemCommandGroup = {
       groupName: p.SYSTEMT_COMMAND_GROUP_NAME,
@@ -127,9 +211,30 @@ const p = class p {
       commandsByLocalName: /* @__PURE__ */ new Map()
     }, this._commandsByGroup.push(this._systemCommandGroup), this._commandsByGroup.push(this._defaultCommandGroup);
   }
+  /**
+   * Gets the singleton instance of the command stack.
+   * Creates a new instance if one doesn't exist.
+   * 
+   * @returns The singleton instance of AcEdCommandStack
+   */
   static get instance() {
     return p._instance || (p._instance = new p()), p._instance;
   }
+  /**
+   * Adds a command to the specified command group.
+   * 
+   * @param cmdGroupName - The name of the command group. If empty, uses the default group.
+   * @param cmdGlobalName - The global (untranslated) name of the command. Must be unique within the group.
+   * @param cmdLocalName - The local (translated) name of the command. Defaults to global name if empty.
+   * @param cmd - The command object to add to the stack.
+   * 
+   * @throws {Error} When the global name is empty or when a command with the same name already exists
+   * 
+   * @example
+   * ```typescript
+   * commandStack.addCommand('USER', 'LINE', 'ligne', new LineCommand());
+   * ```
+   */
   addCommand(t, e, s, n) {
     if (!e)
       throw new Error(
@@ -160,6 +265,7 @@ const p = class p {
   /**
    * Return an iterator that can be used to traverse all of command objects in this command stack
    * (that is, the iterator iterates through all commands in all groups).
+   * 
    * @returns Return an iterator that can be used to traverse all of command objects in this command
    * stack.
    */
@@ -172,7 +278,8 @@ const p = class p {
    * matched AcEdCommand object is returned. Otherwise undefined is returned to indicate that the command
    * could not be found. If more than one command of the same name is present in the command stack (that
    * is, in separate command groups), then the first one found is used.
-   * @param cmdName Input the command name to search for
+   * 
+   * @param cmdName - Input the command name to search for
    * @returns Return the matched AcEdCommand object if a match is found. Otherwise, return undefined.
    */
   lookupGlobalCmd(t) {
@@ -187,7 +294,8 @@ const p = class p {
    * AcEdCommand object is returned. Otherwise undefined is returned to indicate that the command could not
    * be found. If more than one command of the same name is present in the command stack (that is, in
    * separate command groups), then the first one found is used.
-   * @param cmdName Input the command name to search for
+   * 
+   * @param cmdName - Input the command name to search for
    * @returns Return the matched AcEdCommand object if a match is found. Otherwise, return undefined.
    */
   lookupLocalCmd(t) {
@@ -200,8 +308,9 @@ const p = class p {
    * Remove the command with the global and untranslated name `cmdGlobalName` from the `cmdGroupName`
    * command group. Return true if successful. Return false if no command with the global and untranslated
    * name `cmdGlobalName` is found in the `cmdGroupName` command group.
-   * @param cmdGroupName Input the name of the command group containing the command to be removed
-   * @param cmdGlobalName Input the command name which is to be removed from cmdGroupName
+   * 
+   * @param cmdGroupName - Input the name of the command group containing the command to be removed
+   * @param cmdGlobalName - Input the command name which is to be removed from cmdGroupName
    * @returns Return true if successful. Return false if no command with the global and untranslated
    * name `cmdGlobalName` is found in the `cmdGroupName` command group.
    */
@@ -214,7 +323,8 @@ const p = class p {
   /**
    * Remove the command group with the name `GroupName` from the command stack and delete the command group
    * dictionary object and all the AcEdCommand objects stored within it.
-   * @param groupName Input the name of the command group to be removed from the command stack.
+   * 
+   * @param groupName - Input the name of the command group to be removed from the command stack.
    * @returns Return true if successful. Return false if no command group is found with the name `GroupName`.
    */
   removeGroup(t) {
@@ -248,13 +358,34 @@ function ve(i) {
   });
 }
 var C = /* @__PURE__ */ ((i) => (i[i.NoSpecialCursor = -1] = "NoSpecialCursor", i[i.Crosshair = 0] = "Crosshair", i[i.RectCursor = 1] = "RectCursor", i[i.RubberBand = 2] = "RubberBand", i[i.NotRotated = 3] = "NotRotated", i[i.TargetBox = 4] = "TargetBox", i[i.RotatedCrosshair = 5] = "RotatedCrosshair", i[i.CrosshairNoRotate = 6] = "CrosshairNoRotate", i[i.Invisible = 7] = "Invisible", i[i.EntitySelect = 8] = "EntitySelect", i[i.Parallelogram = 9] = "Parallelogram", i[i.EntitySelectNoPersp = 10] = "EntitySelectNoPersp", i[i.PkfirstOrGrips = 11] = "PkfirstOrGrips", i[i.CrosshairDashed = 12] = "CrosshairDashed", i[i.Grab = 13] = "Grab", i))(C || {});
-class Mt {
+class Lt {
+  /**
+   * Creates a new cursor manager instance.
+   * 
+   * Initializes the cursor cache and creates default cursor definitions.
+   */
   constructor() {
     this._cursorMap = /* @__PURE__ */ new Map(), this._cursorMap.set(
       0,
       this.createRectCrossIcon(10, 10)
     );
   }
+  /**
+   * Sets the cursor for the specified HTML element.
+   * 
+   * Applies the appropriate cursor style based on the cursor type.
+   * For built-in cursor types, uses CSS cursor values. For custom
+   * cursor types, uses cached SVG-based cursor definitions.
+   * 
+   * @param cursorType - The type of cursor to set
+   * @param element - The HTML element to apply the cursor to
+   * 
+   * @example
+   * ```typescript
+   * const canvas = document.getElementById('canvas') as HTMLCanvasElement;
+   * cursorManager.setCursor(AcEdCorsorType.Crosshair, canvas);
+   * ```
+   */
   setCursor(t, e) {
     if (t <= -1)
       e.style.cursor = "default";
@@ -266,13 +397,24 @@ class Mt {
     }
   }
   /**
-   * Encode SVG string to one cursor defined using url() in CSS
-   * @param svgString Input svg string
-   * @param xOffset Input x offset for cursor hotspot
-   * @param yOffset Input y offset for cursor hotspot
-   * @returns
-   */
-  encodeSvg(t, e = 0, s = 0) {
+   * Encodes an SVG string into a CSS cursor URL.
+   * 
+   * This method converts SVG markup into a data URI that can be used
+   * as a CSS cursor value, with specified hotspot coordinates.
+   * 
+   * @param svgString - The SVG markup as a string
+   * @param xOffset - X coordinate of the cursor hotspot
+   * @param yOffset - Y coordinate of the cursor hotspot
+   * @returns CSS cursor string in url() format
+   * 
+   * @example
+   * ```typescript
+   * const svgCursor = '<svg width="20" height="20">...</svg>';
+   * const cursorUrl = cursorManager.encodeSvgToCursor(svgCursor, 10, 10);
+   * element.style.cursor = cursorUrl;
+   * ```
+   */
+  encodeSvgToCursor(t, e, s) {
     return `url('data:image/svg+xml;base64,${btoa(t)}') ${e} ${s}, auto`;
   }
   /**
@@ -292,32 +434,68 @@ class Mt {
         <line x1="0" y1="${n + e}" x2="${e}" y2="${n + e}" stroke="${s}" />
       </svg>
     `;
-    return this.encodeSvg(r, n + e, n + e);
+    return this.encodeSvgToCursor(r, n + e, n + e);
   }
 }
 class V {
+  /**
+   * Creates a new base input instance.
+   * 
+   * @param view - The view that will handle this input operation
+   */
   constructor(t) {
     this.active = !1, this.isResolvedOrRejected = !1, this.onKeyDown = (e) => {
       e.code === "Escape" && this.reject("Canceled by user!");
     }, this.view = t;
   }
+  /**
+   * Gets whether this input is currently active.
+   * 
+   * @returns True if the input is active, false otherwise
+   */
   get isActive() {
     return this.active;
   }
+  /**
+   * Activates this input operation.
+   * Sets up event listeners and marks the input as active.
+   * Subclasses should call super.activate() when overriding.
+   */
   activate() {
     this.isActive && console.warn("Something wrong here!"), this.active = !0, this.view.canvas.addEventListener("keydown", this.onKeyDown);
   }
+  /**
+   * Deactivates this input operation.
+   * Removes event listeners and marks the input as inactive.
+   * Subclasses should call super.deactivate() when overriding.
+   */
   deactivate() {
     this.active = !1, this.view.canvas.removeEventListener("keydown", this.onKeyDown);
   }
+  /**
+   * Resolves the input operation with the specified result.
+   * Automatically deactivates the input and prevents multiple resolutions.
+   * 
+   * @param result - The result to resolve the promise with
+   */
   resolve(t) {
     this.deactivate(), this._resolve && !this.isResolvedOrRejected && (this._resolve(t), this.isResolvedOrRejected = !0);
   }
+  /**
+   * Rejects the input operation with the specified reason.
+   * Automatically deactivates the input and prevents multiple rejections.
+   * 
+   * @param reason - The reason for rejecting the input operation
+   */
   reject(t) {
     this.deactivate(), this._reject && !this.isResolvedOrRejected && (this._reject(t), this.isResolvedOrRejected = !0);
   }
   /**
-   * Start inputting
+   * Starts the input operation and returns a promise that resolves with the result.
+   * This method activates the input and returns a promise that will be resolved
+   * when the user completes the input operation.
+   * 
+   * @returns A promise that resolves with the input result
    */
   async start() {
     return this.isResolvedOrRejected = !1, new Promise((t, e) => {
@@ -325,47 +503,182 @@ class V {
     });
   }
 }
-class Et extends V {
+class Mt extends V {
+  /**
+   * Creates a new jig loop instance.
+   * 
+   * @param view - The view that will handle this jig operation
+   */
   constructor(t) {
     super(t), this.events = {
+      /** Event fired when the mouse position updates */
       update: new m()
     }, this.onMouseMove = (e) => {
       this.curPos.set(e.clientX, e.clientY), this.events.update.dispatch();
     }, this.curPos = new u();
   }
+  /**
+   * Activates the jig loop operation.
+   * Sets up the mouse move event listener to track cursor position.
+   * Overrides the base class to add mouse move event handling.
+   */
   activate() {
     super.activate(), this.view.canvas.addEventListener("mousemove", this.onMouseMove);
   }
+  /**
+   * Deactivates the jig loop operation.
+   * Removes the mouse move event listener.
+   * Overrides the base class to clean up mouse move event handling.
+   */
   deactivate() {
     super.deactivate(), this.view.canvas.removeEventListener("mousemove", this.onMouseMove);
   }
 }
-class Lt {
+class Et {
+  /**
+   * Creates a new jig instance for the specified view.
+   * 
+   * Sets up the jig loop and connects update event handling.
+   * 
+   * @param view - The view this jig will operate in
+   */
   constructor(t) {
     this.onUpdate = () => {
       this.update();
-    }, this._view = t, this._jigLoop = new Et(t), this._jigLoop.events.update.addEventListener(this.onUpdate);
+    }, this._view = t, this._jigLoop = new Mt(t), this._jigLoop.events.update.addEventListener(this.onUpdate);
   }
+  /**
+   * Gets the view associated with this jig.
+   * 
+   * @returns The view instance
+   */
   get view() {
     return this._view;
   }
+  /**
+   * Resolves the jig operation with the specified result.
+   * 
+   * This method should be called when the jig operation completes successfully.
+   * It cleans up event listeners and resolves the underlying promise.
+   * 
+   * @param result - The result to return from the jig operation
+   * 
+   * @example
+   * ```typescript
+   * // In a line drawing jig, when user completes the line
+   * if (this.hasValidEndPoint()) {
+   *   const line = new Line(this.startPoint, this.endPoint);
+   *   this.resolve(line);
+   * }
+   * ```
+   */
   resolve(t) {
     this._jigLoop.events.update.removeEventListener(this.onUpdate), this._jigLoop.resolve(t);
   }
+  /**
+   * Rejects the jig operation with an error.
+   * 
+   * This method should be called when the jig operation fails or is cancelled.
+   * It cleans up event listeners and rejects the underlying promise.
+   * 
+   * @param reason - The reason for the rejection
+   * 
+   * @example
+   * ```typescript
+   * // If user cancels or invalid input is detected
+   * if (userPressedEscape) {
+   *   this.reject('Operation cancelled by user');
+   * }
+   * ```
+   */
   reject(t) {
     this._jigLoop.events.update.removeEventListener(this.onUpdate), this._jigLoop.reject(t);
   }
+  /**
+   * Starts the interactive jig operation.
+   * 
+   * This method initiates both the jig loop and the sampling process.
+   * It returns a promise that resolves when the jig operation completes
+   * or rejects if an error occurs.
+   * 
+   * @returns Promise that resolves when the jig operation completes
+   * 
+   * @example
+   * ```typescript
+   * const jig = new MyCustomJig(view);
+   * try {
+   *   const result = await jig.drag();
+   *   console.log('Jig completed with result:', result);
+   * } catch (error) {
+   *   console.log('Jig was cancelled or failed:', error);
+   * }
+   * ```
+   */
   async drag() {
     const t = this._jigLoop.start(), e = this.sampler();
     await Promise.allSettled([t, e]);
   }
+  /**
+   * Abstract method for handling jig input sampling.
+   * 
+   * This method should be overridden by subclasses to implement
+   * the specific input handling logic for the jig. It typically:
+   * - Gets initial user input (like a start point)
+   * - Sets up event listeners for dynamic updates
+   * - Handles user interaction until completion
+   * 
+   * The sampler runs concurrently with the jig loop and should
+   * call `resolve()` or `reject()` when the operation completes.
+   * 
+   * @example
+   * ```typescript
+   * async sampler() {
+   *   // Get initial point
+   *   const startPoint = await this.view.editor.getPoint();
+   *   
+   *   // Set up mouse tracking for dynamic preview
+   *   this.view.events.mouseMove.addEventListener(this.onMouseMove);
+   *   this.view.events.mouseClick.addEventListener(this.onMouseClick);
+   * }
+   * ```
+   */
   async sampler() {
   }
+  /**
+   * Called during each update cycle to refresh the jig display.
+   * 
+   * This method should be overridden by subclasses to implement
+   * the visual update logic. It's called automatically by the jig loop
+   * whenever the display needs to be refreshed (typically on mouse movement).
+   * 
+   * Common update operations include:
+   * - Redrawing preview geometry
+   * - Updating dimension displays
+   * - Refreshing visual feedback elements
+   * 
+   * @example
+   * ```typescript
+   * update() {
+   *   if (this.startPoint && this.currentMousePoint) {
+   *     // Clear previous preview
+   *     this.clearPreview();
+   *     
+   *     // Draw new preview line
+   *     this.drawPreviewLine(this.startPoint, this.currentMousePoint);
+   *   }
+   * }
+   * ```
+   */
   update() {
   }
 }
 const Dt = 16777215, It = "1px";
 class Ct extends V {
+  /**
+   * Creates a new box selector instance.
+   * 
+   * @param view - The view that will handle this box selection operation
+   */
   constructor(t) {
     super(t), this.mouseDown = !1, this.mouseMove = !1, this.mouseDownPositionX = -1, this.mouseDownPositionY = -1, this.mousedown = (e) => {
       if (e.button === 0) {
@@ -402,16 +715,39 @@ class Ct extends V {
       this.mouseDown = !1, this.mouseMove = !1, this.mouseDownPositionX = -1, this.mouseDownPositionY = -1;
     }, this.container = t.canvas, this.color = Dt;
   }
+  /**
+   * Activates the box selector.
+   * Sets up mouse event listeners for tracking selection area.
+   * Overrides the base class to add mouse event handling.
+   */
   activate() {
     super.activate(), this.active = !0, this.container.addEventListener("pointerdown", this.mousedown), this.container.addEventListener("pointermove", this.mousemove), this.container.addEventListener("pointerup", this.mouseup);
   }
+  /**
+   * Deactivates the box selector.
+   * Removes mouse event listeners and hides the selection box.
+   * Overrides the base class to clean up mouse event handling.
+   */
   deactivate() {
     super.deactivate(), this.container.removeEventListener("pointerdown", this.mousedown), this.container.removeEventListener("pointermove", this.mousemove), this.container.removeEventListener("pointerup", this.mouseup), this.setRectDomVisible(!1);
   }
+  /**
+   * Rejects the box selection operation.
+   * Cleans up the selection box DOM element.
+   * 
+   * @param reason - The reason for rejecting the selection operation
+   */
   reject(t) {
     var e;
     super.reject(t), (e = this.boxDom) == null || e.remove(), this.boxDom = void 0;
   }
+  /**
+   * Draws the selection rectangle on screen.
+   * Creates or updates the DOM element representing the selection box.
+   * 
+   * @param leftTop - The top-left corner of the selection rectangle
+   * @param rightBottom - The bottom-right corner of the selection rectangle
+   */
   drawRect(t, e) {
     if (!this.boxDom) {
       const o = new k();
@@ -421,75 +757,245 @@ class Ct extends V {
     const s = Math.abs(e.x - t.x), n = Math.abs(e.y - t.y);
     this.boxDom.style.width = `${s}px`, this.boxDom.style.height = `${n}px`;
   }
+  /**
+   * Sets the visibility of the selection rectangle DOM element.
+   * 
+   * @param visible - Whether the selection rectangle should be visible
+   */
   setRectDomVisible(t) {
     this.boxDom && (this.boxDom.style.display = t ? "inline-block" : "none");
   }
+  /**
+   * Converts a screen coordinate box to world coordinate system.
+   * Transforms the selection box from screen coordinates to world coordinates
+   * for use in entity selection operations.
+   * 
+   * @param box - The selection box in screen coordinates
+   * @returns The selection box in world coordinates
+   */
   toWcs(t) {
     const e = new N(), s = new u(t.min.x, t.min.y), n = new u(t.max.x, t.max.y);
     return e.expandByPoint(this.view.cwcs2Wcs(s)), e.expandByPoint(this.view.cwcs2Wcs(n)), e;
   }
 }
 class Tt extends V {
+  /**
+   * Creates a new point input instance.
+   * 
+   * @param view - The view that will handle this point input operation
+   */
   constructor(t) {
     super(t), this.onClick = (e) => {
       this.resolve(this.view.cwcs2Wcs({ x: e.clientX, y: e.clientY }));
     };
   }
+  /**
+   * Activates the point input operation.
+   * Sets up the click event listener to capture user point selection.
+   * Overrides the base class to add click event handling.
+   */
   activate() {
     super.activate(), this.view.canvas.addEventListener("click", this.onClick);
   }
+  /**
+   * Deactivates the point input operation.
+   * Removes the click event listener.
+   * Overrides the base class to clean up click event handling.
+   */
   deactivate() {
     super.deactivate(), this.view.canvas.removeEventListener("click", this.onClick);
   }
 }
 class At {
+  /**
+   * Creates a new editor instance for the specified view.
+   * 
+   * @param view - The view that this editor will handle input for
+   */
   constructor(t) {
-    this._view = t, this._cursorManager = new Mt();
+    this._view = t, this._cursorManager = new Lt();
   }
+  /**
+   * Gets the currently active cursor type.
+   * 
+   * @returns The current cursor type, or undefined if none is set
+   */
   get currentCursor() {
     return this._currentCursor;
   }
+  /**
+   * Restores the previously set cursor.
+   * 
+   * This is useful for temporarily changing the cursor and then reverting
+   * to the previous state.
+   */
   restoreCursor() {
     this._previousCursor != null && this.setCursor(this._previousCursor);
   }
+  /**
+   * Sets the cursor appearance for the view.
+   * 
+   * The previous cursor type is stored for potential restoration.
+   * 
+   * @param cursorType - The cursor type to set
+   * 
+   * @example
+   * ```typescript
+   * editor.setCursor(AcEdCorsorType.Crosshair);  // For precise point input
+   * editor.setCursor(AcEdCorsorType.Grab);       // For pan operations
+   * ```
+   */
   setCursor(t) {
     this._cursorManager.setCursor(t, this._view.canvas), this._previousCursor = this._currentCursor, this._currentCursor = t;
   }
   /**
-   * Get user input for a point.
+   * Prompts the user to input a point by clicking on the view.
+   * 
+   * This method returns a promise that resolves when the user clicks
+   * on the view, providing the world coordinates of the click point.
+   * 
+   * @returns Promise that resolves to the input point coordinates
+   * 
+   * @example
+   * ```typescript
+   * const startPoint = await editor.getPoint();
+   * const endPoint = await editor.getPoint();
+   * // Now you can create a line from startPoint to endPoint
+   * ```
    */
   async getPoint() {
     return await new Tt(this._view).start();
   }
   /**
-   * Get the selection set obtained.
+   * Prompts the user to select entities using box selection.
+   * 
+   * This method allows the user to drag a selection box to select
+   * multiple entities at once. The selection behavior follows CAD
+   * conventions (left-to-right for crossing, right-to-left for window).
+   * 
+   * @returns Promise that resolves to the selection set containing selected entity IDs
+   * 
+   * @example
+   * ```typescript
+   * const selection = await editor.getSelection();
+   * if (selection.count > 0) {
+   *   console.log(`Selected ${selection.count} entities`);
+   *   // Process the selected entities
+   *   for (const id of selection.ids) {
+   *     // Do something with each selected entity
+   *   }
+   * }
+   * ```
    */
   async getSelection() {
     return await new Ct(this._view).start();
   }
 }
 class Ot {
+  /**
+   * Creates a new selection set.
+   * 
+   * @param ids - Optional initial array of entity IDs to include in the selection
+   * 
+   * @example
+   * ```typescript
+   * // Create empty selection set
+   * const selectionSet = new AcEdSelectionSet();
+   * 
+   * // Create selection set with initial entities
+   * const selectionSet = new AcEdSelectionSet(['entity1', 'entity2']);
+   * ```
+   */
   constructor(t = []) {
     this.events = {
+      /** Fired when entities are added to the selection */
       selectionAdded: new m(),
+      /** Fired when entities are removed from the selection */
       selectionRemoved: new m()
     }, this._ids = new Set(t);
   }
+  /**
+   * Gets an array of all selected entity IDs.
+   * 
+   * @returns Array containing all selected entity IDs
+   */
   get ids() {
     return Array.from(this._ids);
   }
+  /**
+   * Gets the number of selected entities.
+   * 
+   * @returns The count of selected entities
+   */
   get count() {
     return this._ids.size;
   }
+  /**
+   * Adds one or more entities to the selection.
+   * 
+   * Fires a `selectionAdded` event with the added entity IDs.
+   * Duplicate IDs are automatically handled by the internal Set.
+   * 
+   * @param value - Single entity ID or array of entity IDs to add
+   * 
+   * @example
+   * ```typescript
+   * // Add single entity
+   * selectionSet.add('entity1');
+   * 
+   * // Add multiple entities
+   * selectionSet.add(['entity2', 'entity3', 'entity4']);
+   * ```
+   */
   add(t) {
     Array.isArray(t) ? (t.forEach((e) => this._ids.add(e)), this.events.selectionAdded.dispatch({ ids: t })) : (this._ids.add(t), this.events.selectionAdded.dispatch({ ids: [t] }));
   }
+  /**
+   * Removes one or more entities from the selection.
+   * 
+   * Fires a `selectionRemoved` event with the removed entity IDs.
+   * Non-existent IDs are silently ignored.
+   * 
+   * @param value - Single entity ID or array of entity IDs to remove
+   * 
+   * @example
+   * ```typescript
+   * // Remove single entity
+   * selectionSet.delete('entity1');
+   * 
+   * // Remove multiple entities
+   * selectionSet.delete(['entity2', 'entity3']);
+   * ```
+   */
   delete(t) {
     Array.isArray(t) ? (t.forEach((e) => this._ids.delete(e)), this.events.selectionRemoved.dispatch({ ids: t })) : (this._ids.delete(t), this.events.selectionRemoved.dispatch({ ids: [t] }));
   }
+  /**
+   * Checks if an entity is currently selected.
+   * 
+   * @param id - The entity ID to check
+   * @returns True if the entity is selected, false otherwise
+   * 
+   * @example
+   * ```typescript
+   * if (selectionSet.has('entity1')) {
+   *   console.log('Entity1 is selected');
+   * }
+   * ```
+   */
   has(t) {
     return this._ids.has(t);
   }
+  /**
+   * Removes all entities from the selection.
+   * 
+   * Fires a `selectionRemoved` event with all previously selected entity IDs.
+   * 
+   * @example
+   * ```typescript
+   * selectionSet.clear(); // Deselect everything
+   * ```
+   */
   clear() {
     if (this._ids.size > 0) {
       const t = Array.from(this._ids);
@@ -499,11 +1005,23 @@ class Ot {
 }
 var y = /* @__PURE__ */ ((i) => (i[i.SELECTION = 0] = "SELECTION", i[i.PAN = 1] = "PAN", i))(y || {});
 class Nt {
+  /**
+   * Creates a new base view instance.
+   * 
+   * Sets up the canvas, initializes internal state, and registers event listeners
+   * for mouse interactions and window resize events.
+   * 
+   * @param canvas - The HTML canvas element to render into
+   */
   constructor(t) {
     this.events = {
+      /** Fired when mouse moves over the view */
       mouseMove: new m(),
+      /** Fired when the view is resized */
       viewResize: new m(),
+      /** Fired when mouse hovers over an entity */
       hover: new m(),
+      /** Fired when mouse stops hovering over an entity */
       unhover: new m()
     }, this._canvas = t;
     const e = t.getBoundingClientRect();
@@ -514,17 +1032,32 @@ class Nt {
     }), window.addEventListener("resize", this.onWindowResize.bind(this)), this._selectionBoxSize = 4, this._hoverTimer = null, this._pauseTimer = null, this._hoveredObjectId = null;
   }
   /**
-   * The input manager
+   * Gets the input manager for handling user interactions.
+   * 
+   * The editor provides high-level methods for getting user input like
+   * point selection, entity selection, and cursor management.
+   * 
+   * @returns The editor instance
    */
   get editor() {
     return this._editor;
   }
   /**
-   * The size of selection box in pixel unit
+   * Gets the size of the selection box used for entity picking.
+   * 
+   * This determines how close the mouse needs to be to an entity
+   * to select it, measured in screen pixels.
+   * 
+   * @returns Selection box size in pixels
    */
   get selectionBoxSize() {
     return this._selectionBoxSize;
   }
+  /**
+   * Sets the size of the selection box used for entity picking.
+   * 
+   * @param value - Selection box size in pixels
+   */
   set selectionBoxSize(t) {
     this._selectionBoxSize = t;
   }
@@ -646,9 +1179,28 @@ class Nt {
   }
 }
 class Pt {
+  /**
+   * Creates a new document instance with an empty database.
+   * 
+   * The document is initialized with an "Untitled" title and read-only mode enabled.
+   */
   constructor() {
     this._fileName = "", this._docTitle = "", this._isReadOnly = !0, this._database = new J(), this.docTitle = "Untitled";
   }
+  /**
+   * Opens a CAD document from a URI.
+   * 
+   * @param uri - The URI of the CAD file to open
+   * @param options - Options for opening the database, including read-only mode
+   * @returns Promise resolving to true if successful, false if failed
+   * 
+   * @example
+   * ```typescript
+   * const success = await document.openUri('https://example.com/drawing.dwg', {
+   *   readOnly: true
+   * });
+   * ```
+   */
   async openUri(t, e) {
     this._uri = t, this._isReadOnly = e && e.readOnly || !1, this._fileName = this.getFileNameFromUri(t);
     let s = !0;
@@ -659,6 +1211,22 @@ class Pt {
     }
     return s;
   }
+  /**
+   * Opens a CAD document from file content.
+   * 
+   * @param fileName - The name of the file (used to determine file type from extension)
+   * @param content - The file content as string or ArrayBuffer
+   * @param options - Options for opening the database, including read-only mode
+   * @returns Promise resolving to true if successful, false if failed
+   * 
+   * @example
+   * ```typescript
+   * const fileContent = await fetch('drawing.dwg').then(r => r.arrayBuffer());
+   * const success = await document.openDocument('drawing.dwg', fileContent, {
+   *   readOnly: false
+   * });
+   * ```
+   */
   async openDocument(t, e, s) {
     var o;
     let n = !0;
@@ -675,30 +1243,55 @@ class Pt {
     }
     return n;
   }
+  /**
+   * Gets the URI of the document if opened from a URI.
+   * 
+   * @returns The document URI, or undefined if not opened from URI
+   */
   get uri() {
     return this._uri;
   }
   /**
-   * The database object being used by this document instance.
+   * Gets the database object containing all drawing data.
+   * 
+   * @returns The underlying CAD database instance
    */
   get database() {
     return this._database;
   }
   /**
-   * The window title of the document
+   * Gets the display title of the document.
+   * 
+   * @returns The document title displayed in the window/tab
    */
   get docTitle() {
     return this._docTitle;
   }
+  /**
+   * Sets the display title of the document.
+   * 
+   * Also updates the browser tab title if running in a browser environment.
+   * 
+   * @param value - The new document title
+   */
   set docTitle(t) {
     this._docTitle = t, typeof document < "u" && (document.title = t);
   }
   /**
-   * Return true if the document is read only; otherwise, returns false.
+   * Gets whether the document is opened in read-only mode.
+   * 
+   * @returns True if the document is read-only, false if editable
    */
   get isReadOnly() {
     return this._isReadOnly;
   }
+  /**
+   * Extracts the file name from a URI.
+   * 
+   * @param uri - The URI to extract the file name from
+   * @returns The extracted file name, or empty string if extraction fails
+   * @private
+   */
   getFileNameFromUri(t) {
     try {
       const s = new URL(t).pathname.split("/");
@@ -709,12 +1302,39 @@ class Pt {
   }
 }
 class Rt {
+  /**
+   * Converts the current CAD drawing to SVG format and initiates download.
+   * 
+   * This method:
+   * - Retrieves all entities from the current document's model space
+   * - Renders each entity using the SVG renderer
+   * - Exports the complete SVG markup
+   * - Automatically downloads the SVG file as 'example.svg'
+   * 
+   * @example
+   * ```typescript
+   * const converter = new AcApSvgConvertor();
+   * converter.convert(); // Downloads the drawing as SVG
+   * ```
+   */
   convert() {
     const t = w.instance.curDocument.database.tables.blockTable.modelSpace.newIterator(), e = new dt();
     for (const s of t)
       s.draw(e);
     this.createFileAndDownloadIt(e.export());
   }
+  /**
+   * Creates a downloadable SVG file and triggers the download.
+   * 
+   * This method:
+   * - Creates a Blob from the SVG content with proper MIME type
+   * - Generates a temporary download URL
+   * - Creates and triggers a download link
+   * - Cleans up the temporary elements
+   * 
+   * @param svgContent - The SVG markup content to download
+   * @private
+   */
   createFileAndDownloadIt(t) {
     const e = new Blob([t], {
       type: "image/svg+xml;charset=utf-8"
@@ -723,44 +1343,115 @@ class Rt {
   }
 }
 class zt extends x {
+  /**
+   * Executes the SVG conversion command.
+   * 
+   * Creates a converter instance and initiates the conversion process
+   * for the current document.
+   * 
+   * @param _context - The application context (unused in this command)
+   */
   execute(t) {
     new Rt().convert();
   }
 }
 class Vt extends x {
+  /**
+   * Executes the open file command.
+   * 
+   * Emits an 'open-file' event on the global event bus to trigger
+   * the file opening workflow. UI components typically listen for
+   * this event to display file selection dialogs.
+   * 
+   * @param _context - The current application context (not used in this command)
+   */
   execute(t) {
     v.emit("open-file", {});
   }
 }
 class Gt extends x {
+  /**
+   * Executes the quick new command.
+   * 
+   * Opens the ISO template from the CDN to create a new document
+   * with standard drawing settings.
+   * 
+   * @param _context - The application context (unused in this command)
+   */
   execute(t) {
     w.instance.openUrl("https://cdn.jsdelivr.net/gh/mlight-lee/cad-data/templates/" + "acadiso.dxf");
   }
 }
 class jt extends x {
+  /**
+   * Executes the select command.
+   * 
+   * Sets the view to selection mode and updates the cursor appearance
+   * to indicate that entity selection is active.
+   * 
+   * @param context - The application context containing the view
+   */
   execute(t) {
     t.view.mode = y.SELECTION, t.view.setCursor(C.Crosshair);
   }
 }
 class Yt extends x {
+  /**
+   * Executes the zoom to fit command.
+   * 
+   * Calls the view's `zoomToFit()` method to adjust the camera position
+   * and zoom level to display all visible entities within the viewport.
+   * 
+   * @param context - The current application context containing the view to zoom
+   */
   execute(t) {
     t.view.zoomToFit();
   }
 }
-class Xt extends Lt {
+class Xt extends Et {
+  /**
+   * Creates a new zoom-to-box jig.
+   * 
+   * @param view - The view that will be zoomed
+   */
   constructor(t) {
     super(t);
   }
+  /**
+   * Handles the selection sampling and zooming operation.
+   * 
+   * This method gets the user's selection box and applies
+   * the zoom operation to fit that area in the view.
+   * 
+   * @returns Promise that resolves when the zoom operation completes
+   */
   async sampler() {
     await w.instance.editor.getSelection().then((t) => this.view.zoomTo(t, 1));
   }
 }
 class Ft extends x {
+  /**
+   * Executes the zoom-to-box command.
+   * 
+   * Creates a jig for interactive area selection and initiates
+   * the drag operation for the user to select the zoom area.
+   * 
+   * @param context - The application context containing the view
+   * @returns Promise that resolves when the zoom operation completes
+   */
   async execute(t) {
     await new Xt(t.view).drag();
   }
 }
 class Ut extends x {
+  /**
+   * Executes the pan command.
+   * 
+   * Sets the view to pan mode and updates the cursor appearance
+   * to indicate that panning is active.
+   * 
+   * @param context - The application context containing the view
+   */
   execute(t) {
     t.view.mode = y.PAN, t.view.setCursor(C.Grab);
   }
@@ -775,29 +1466,42 @@ const kt = (i) => new $(i.min, i.max), $t = (i) => new f.Box3(
   const t = new f.Box3();
   return t.min.set(i.min.x, i.min.y, 0), t.max.set(i.max.x, i.max.y, 0), t;
 }, Kt = {
+  /** Converts Three.js Box2 to CAD geometry Box2d */
   threeBo2dToGeBox2d: Wt,
+  /** Converts CAD geometry Box2d to Three.js Box2 */
   goBox2dToThreeBox2d: Ht,
+  /** Converts Three.js Box3 to CAD geometry Box3d */
   threeBox3dToGeBox3d: kt,
+  /** Converts CAD geometry Box3d to Three.js Box3 */
   goBox3dToThreeBox3d: $t,
+  /** Converts Three.js Box3 to CAD geometry Box2d (ignores Z) */
   threeBox3dToGeBox2d: qt,
+  /** Converts CAD geometry Box2d to Three.js Box3 (Z=0) */
   goBox2dToThreeBox3d: Jt
 };
 class Zt extends wt {
   /**
-   * Construct one instance of this class
-   * @param layoutBtrId Input the id of the block table record associated the layout
-   * @param renderer Input renderer
-   * @param width Input width of this view
-   * @param height Input height of this view
+   * Construct one instance of this class.
+   * 
+   * @param renderer - Input renderer for this view
+   * @param layoutBtrId - Input the id of the block table record associated the layout
+   * @param width - Input width of this view in pixels
+   * @param height - Input height of this view in pixels
    */
   constructor(t, e, s, n) {
     super(t, s, n), this._layoutBtrId = e, this._mode = y.SELECTION, this._axesGizmo = this.createAxesGizmo(), this._viewportViews = /* @__PURE__ */ new Map();
   }
+  /**
+   * Gets the block table record ID associated with this layout.
+   * 
+   * @returns The layout's block table record ID
+   */
   get layoutBtrId() {
     return this._layoutBtrId;
   }
   /**
-   * The view mode of the current layout view
+   * The view mode of the current layout view.
+   * Controls how mouse interactions are interpreted (selection vs pan mode).
    */
   get mode() {
     return this._mode;
@@ -810,41 +1514,61 @@ class Zt extends wt {
     }), this._cameraControls.update(), this._mode = t;
   }
   /**
-   * The number of viewports in this layout view
+   * The number of viewports in this layout view.
+   * Paper space layouts can contain multiple viewports showing different views of model space.
    */
   get viewportCount() {
     return this._viewportViews.size;
   }
   /**
-   * Add one viewport view instance to this layout view
-   * @param viewportView Input one viewport instance
+   * Add one viewport view instance to this layout view.
+   * Viewports are used in paper space layouts to show different views of the model.
+   * 
+   * @param viewportView - Input one viewport instance to add
    */
   addViewport(t) {
     this._viewportViews.set(t.viewport.id, t);
   }
   /**
-   * Remove the specified viewport view by its id from this layout view
-   * @param id Input the id of one viewport instance
+   * Remove the specified viewport view by its id from this layout view.
+   * 
+   * @param id - Input the id of one viewport instance to remove
    */
   removeViewport(t) {
     this._viewportViews.delete(t);
   }
   /**
-   * Resize this layout view
-   * @param width Input new width of the layout view
-   * @param height Input new height of the layout view
+   * Resize this layout view.
+   * Updates the view dimensions and notifies all viewports of the size change.
+   * 
+   * @param width - Input new width of the layout view in pixels
+   * @param height - Input new height of the layout view in pixels
    */
   resize(t, e) {
     this._height = e, this._width = t, this.updateCameraFrustum(), this._viewportViews.forEach((s) => {
       s.update();
     });
   }
+  /**
+   * Renders the scene in this layout view.
+   * Performs the main rendering pass and then renders any viewports if present.
+   * Updates the axes gizmo to reflect the current camera orientation.
+   * 
+   * @param scene - The scene containing the layout data to render
+   */
   render(t) {
     var s;
     this._renderer.clear(), this._renderer.render(t.internalScene, this._camera);
     const e = t.modelSpaceLayout;
     e && this.drawViewports(e.internalObject), (s = this._axesGizmo) == null || s.update();
   }
+  /**
+   * Creates and configures the axes gizmo for this view.
+   * The gizmo shows the current coordinate system orientation and is positioned
+   * at the bottom-left of the view without a Z-axis (2D view).
+   * 
+   * @returns The configured axes gizmo instance
+   */
   createAxesGizmo() {
     return new gt(
       this._camera.internalCamera,
@@ -856,8 +1580,11 @@ class Zt extends wt {
     );
   }
   /**
-   * Draw viewports
-   * @param scene Input the scene to draw
+   * Draw viewports into the current rendering context.
+   * Handles the complex rendering process for paper space layouts that contain
+   * multiple viewports, each with their own view of model space.
+   * 
+   * @param scene - Input the scene object to draw in each viewport
    */
   drawViewports(t) {
     if (this._viewportViews.size > 0) {
@@ -878,11 +1605,17 @@ class Zt extends wt {
   }
 }
 class Qt {
+  /**
+   * Creates a new layout view manager instance.
+   * Initializes with no active layout and an empty collection of views.
+   */
   constructor() {
     this._activeLayoutBtrId = "", this._layoutViews = /* @__PURE__ */ new Map();
   }
   /**
-   * The block table record id associated with the active layout
+   * The block table record id associated with the active layout.
+   * Setting this property switches the active layout and enables/disables
+   * the appropriate layout views.
    */
   get activeLayoutBtrId() {
     return this._activeLayoutBtrId;
@@ -894,44 +1627,60 @@ class Qt {
   }
   /**
    * The active layout view.
+   * Returns the layout view corresponding to the currently active layout,
+   * or undefined if no layout is active or the active layout doesn't exist.
    */
   get activeLayoutView() {
     return this._layoutViews.get(this._activeLayoutBtrId);
   }
   /**
-   * Return true if the layout view manager contains one layout view associated with the sepcified block
+   * Return true if the layout view manager contains one layout view associated with the specified block
    * table record id. Otherwise it returns false.
-   * @param name Input the block table record id associated with the layout view
-   * @returns Return true if the layout view manager contains one layout view associated with the sepcified
+   * 
+   * @param layoutBtrId - Input the block table record id associated with the layout view
+   * @returns Return true if the layout view manager contains one layout view associated with the specified
    * block table record id. Otherwise it returns false.
    */
   has(t) {
     return this._layoutViews.has(t);
   }
   /**
-   * Get the layout view by the block table record id associated with the layout
-   * @param layoutBtrId Input the id of the block table record associated the layout
-   * @returns Return the layout view by the block table record id associated with the layout
+   * Get the layout view by the block table record id associated with the layout.
+   * 
+   * @param layoutBtrId - Input the id of the block table record associated the layout
+   * @returns Return the layout view by the block table record id associated with the layout,
+   * or undefined if not found
    */
   getAt(t) {
     return this._layoutViews.get(t);
   }
   /**
-   * Resize all of layout views managed by layout view manager
-   * @param width Input new width of the layout view
-   * @param height Input new height of the layout view
+   * Resize all of layout views managed by layout view manager.
+   * This is typically called when the viewport or container size changes
+   * and all layouts need to update their dimensions.
+   * 
+   * @param width - Input new width of the layout view in pixels
+   * @param height - Input new height of the layout view in pixels
    */
   resize(t, e) {
     this._layoutViews.forEach((s) => {
       s.resize(t, e);
     });
   }
+  /**
+   * Adds a layout view to the manager.
+   * The layout view is indexed by its block table record ID for fast lookup.
+   * 
+   * @param layoutView - The layout view to add to the manager
+   */
   add(t) {
     this._layoutViews.set(t.layoutBtrId, t);
   }
   /**
-   * Render the specified scene in the current layout view
-   * @param scene Input the scene to render
+   * Render the specified scene in the current layout view.
+   * Only renders the currently active layout view, if one is set.
+   * 
+   * @param scene - Input the scene to render
    */
   render(t) {
     var e;
@@ -946,14 +1695,14 @@ function H(i, t, e = 0, s = i.length - 1, n = te) {
     }
     const o = i[t];
     let r = e, a = s;
-    for (E(i, e, t), n(i[s], o) > 0 && E(i, e, s); r < a; ) {
-      for (E(i, r, a), r++, a--; n(i[r], o) < 0; ) r++;
+    for (M(i, e, t), n(i[s], o) > 0 && M(i, e, s); r < a; ) {
+      for (M(i, r, a), r++, a--; n(i[r], o) < 0; ) r++;
       for (; n(i[a], o) > 0; ) a--;
     }
-    n(i[e], o) === 0 ? E(i, e, a) : (a++, E(i, a, s)), a <= t && (e = a + 1), t <= a && (s = a - 1);
+    n(i[e], o) === 0 ? M(i, e, a) : (a++, M(i, a, s)), a <= t && (e = a + 1), t <= a && (s = a - 1);
   }
 }
-function E(i, t, e) {
+function M(i, t, e) {
   const s = i[t];
   i[t] = i[e], i[e] = s;
 }
@@ -1108,7 +1857,7 @@ class ee {
   _chooseSplitIndex(t, e, s) {
     let n, o = 1 / 0, r = 1 / 0;
     for (let a = e; a <= s - e; a++) {
-      const c = L(t, 0, a, this.toBBox), l = L(t, a, s, this.toBBox), h = re(c, l), d = R(c) + R(l);
+      const c = E(t, 0, a, this.toBBox), l = E(t, a, s, this.toBBox), h = re(c, l), d = R(c) + R(l);
       h < o ? (o = h, n = a, r = d < r ? d : r) : h === o && d < r && (r = d, n = a);
     }
     return n || s - e;
@@ -1121,7 +1870,7 @@ class ee {
   // total margin of all possible split distributions where each node is at least m full
   _allDistMargin(t, e, s, n) {
     t.children.sort(n);
-    const o = this.toBBox, r = L(t, 0, e, o), a = L(t, s - e, s, o);
+    const o = this.toBBox, r = E(t, 0, e, o), a = E(t, s - e, s, o);
     let c = A(r) + A(a);
     for (let l = e; l < s - e; l++) {
       const h = t.children[l];
@@ -1149,9 +1898,9 @@ function se(i, t, e) {
   return -1;
 }
 function b(i, t) {
-  L(i, 0, i.children.length, t, i);
+  E(i, 0, i.children.length, t, i);
 }
-function L(i, t, e, s, n) {
+function E(i, t, e, s, n) {
   n || (n = S(null)), n.minX = 1 / 0, n.minY = 1 / 0, n.maxX = -1 / 0, n.maxY = -1 / 0;
   for (let o = t; o < e; o++) {
     const r = i.children[o];
@@ -1329,6 +2078,10 @@ class ae {
   }
 }
 class ce {
+  /**
+   * Creates a new layout instance.
+   * Initializes the layout with empty collections and a spatial index.
+   */
   constructor() {
     this._group = new f.Group(), this._indexTree = new ee(), this._box = new f.Box3(), this._layers = /* @__PURE__ */ new Map();
   }
@@ -1339,14 +2092,25 @@ class ce {
   get internalObject() {
     return this._group;
   }
+  /**
+   * Gets the map of layers in this layout.
+   * 
+   * @returns Map of layer names to layer objects
+   */
   get layers() {
     return this._layers;
   }
+  /**
+   * Gets the bounding box that contains all entities in this layout.
+   * 
+   * @returns The layout's bounding box
+   */
   get box() {
     return this._box;
   }
   /**
-   * The visibility of this layout
+   * The visibility of this layout.
+   * When set to false, the entire layout and all its contents are hidden.
    */
   get visible() {
     return this._group.visible;
@@ -1355,14 +2119,16 @@ class ce {
     this._group.visible = t;
   }
   /**
-   * The number of entities stored in this layer
+   * The number of entities stored in this layout.
+   * Calculates the total by summing entities across all layers.
    */
   get entityCount() {
     let t = 0;
     return this._layers.forEach((e) => t += e.entityCount), t;
   }
   /**
-   * The statistics of this layout
+   * The statistics of this layout.
+   * Provides detailed information about memory usage and entity counts.
    */
   get stats() {
     const t = [];
@@ -1384,14 +2150,22 @@ class ce {
       }
     };
   }
+  /**
+   * Clears all entities from the layout.
+   * Removes all layers, resets the bounding box, and clears the spatial index.
+   * 
+   * @returns This layout instance for method chaining
+   */
   clear() {
     return this._layers.forEach((t) => {
       this._group.remove(t.internalObject);
     }), this._layers.clear(), this._box.makeEmpty(), this._indexTree.clear(), this;
   }
   /**
-   * Re-render points with latest point style settings
-   * @param displayMode Input display mode of points
+   * Re-render points with latest point style settings.
+   * Updates the visual representation of all point entities across all layers.
+   * 
+   * @param displayMode - Input display mode of points
    */
   rerenderPoints(t) {
     this._layers.forEach((e) => {
@@ -1400,8 +2174,10 @@ class ce {
   }
   /**
    * Return true if the object with the specified object id is intersected with the ray by using raycast.
-   * @param objectId  Input object id of object to check for intersection with the ray.
-   * @param raycaster Input raycaster to check intersection
+   * 
+   * @param objectId - Input object id of object to check for intersection with the ray.
+   * @param raycaster - Input raycaster to check intersection
+   * @returns True if the object intersects with the ray, false otherwise
    */
   isIntersectWith(t, e) {
     const s = this.getLayerByObjectId(t);
@@ -1410,9 +2186,13 @@ class ce {
   /**
    * Add one AutoCAD entity into this layout. If layer group referenced by the entity doesn't exist, create one
    * layer group and add this entity this group.
-   * @param entity Input AutoCAD entity to be added into this layout.
-   * @param extendBbox Input the flag whether to extend the bounding box of the scene by union the bounding box
-   * of the specified entity.
+   * 
+   * @param entity - Input AutoCAD entity to be added into this layout.
+   * @param extendBbox - Input the flag whether to extend the bounding box of the scene by union the bounding box
+   * of the specified entity. Defaults to true.
+   * @returns This layout instance for method chaining
+   * 
+   * @throws {Error} When entity is missing required objectId or layerName
    */
   addEntity(t, e = !0) {
     if (!t.objectId)
@@ -1435,7 +2215,8 @@ class ce {
   }
   /**
    * Remove the specified entity from this layout.
-   * @param objectId Input the object id of the entity to remove
+   * 
+   * @param objectId - Input the object id of the entity to remove
    * @returns Return true if remove the specified entity successfully. Otherwise, return false.
    */
   remove(t) {
@@ -1445,7 +2226,8 @@ class ce {
   }
   /**
    * Update the specified entity in this layout.
-   * @param objectId Input the entity to update
+   * 
+   * @param entity - Input the entity to update
    * @returns Return true if update the specified entity successfully. Otherwise, return false.
    */
   update(t) {
@@ -1454,7 +2236,10 @@ class ce {
     return !1;
   }
   /**
-   * Hover the specified entities
+   * Hover the specified entities.
+   * Applies hover highlighting to the entities with the given IDs.
+   * 
+   * @param ids - Array of entity object IDs to hover
    */
   hover(t) {
     t.forEach((e) => {
@@ -1463,7 +2248,10 @@ class ce {
     });
   }
   /**
-   * Unhover the specified entities
+   * Unhover the specified entities.
+   * Removes hover highlighting from the entities with the given IDs.
+   * 
+   * @param ids - Array of entity object IDs to unhover
    */
   unhover(t) {
     t.forEach((e) => {
@@ -1472,7 +2260,10 @@ class ce {
     });
   }
   /**
-   * Select the specified entities
+   * Select the specified entities.
+   * Applies selection highlighting to the entities with the given IDs.
+   * 
+   * @param ids - Array of entity object IDs to select
    */
   select(t) {
     t.forEach((e) => {
@@ -1481,7 +2272,10 @@ class ce {
     });
   }
   /**
-   * Unselect the specified entities
+   * Unselect the specified entities.
+   * Removes selection highlighting from the entities with the given IDs.
+   * 
+   * @param ids - Array of entity object IDs to unselect
    */
   unselect(t) {
     t.forEach((e) => {
@@ -1489,13 +2283,21 @@ class ce {
       s && s.unselect([e]);
     });
   }
+  /**
+   * Sets the snap points object for this layout.
+   * Replaces any existing snap points object with the new one.
+   * 
+   * @param object - The snap points object to display
+   */
   setSnapObject(t) {
     this._snapPointsObject && this._group.remove(this._snapPointsObject), this._snapPointsObject = t, this._group.add(t);
   }
   /**
    * Search entities intersected or contained in the specified bounding box.
-   * @param box Input the query bounding box
-   * @returns Return query results
+   * Uses the spatial index for efficient querying of entities within the given bounds.
+   * 
+   * @param box - Input the query bounding box (2D or 3D)
+   * @returns Return query results containing entity IDs and their bounds
    */
   search(t) {
     return this._indexTree.search({
@@ -1505,16 +2307,23 @@ class ce {
       maxY: t.max.y
     });
   }
+  /**
+   * Finds the layer containing the entity with the specified object ID.
+   * 
+   * @param objectId - The object ID to search for
+   * @returns The layer containing the entity, or undefined if not found
+   */
   getLayerByObjectId(t) {
     for (const [e, s] of this._layers)
       if (s.hasEntity(t)) return s;
   }
   /**
    * Get layer group by name. If the layer doesn't exist, create one layer group into this layout.
-   * @param name Input layer name
-   * @param createIfNotExist Input one flag to indicate whether to create layer group if it doesn't exist in
-   * this layout.
-   * @returns Return matched layer
+   * 
+   * @param name - Input layer name
+   * @param createIfNotExist - Input one flag to indicate whether to create layer group if it doesn't exist in
+   * this layout. Defaults to true.
+   * @returns Return matched layer, or undefined if not found and createIfNotExist is false
    */
   getLayer(t, e = !0) {
     let s = this._layers.get(t);
@@ -1522,6 +2331,11 @@ class ce {
   }
 }
 class he {
+  /**
+   * Creates a new CAD scene instance.
+   * 
+   * Initializes the Three.js scene and layout management structures.
+   */
   constructor() {
     this._scene = new f.Scene(), this._layouts = /* @__PURE__ */ new Map(), this._activeLayoutBtrId = "", this._modelSpaceBtrId = "";
   }
@@ -1700,6 +2514,14 @@ const X = {
   background: 0
 };
 class le extends Nt {
+  /**
+   * Creates a new 2D CAD viewer instance.
+   * 
+   * @param options - Configuration options for the viewer
+   * @param options.canvas - Optional HTML canvas element. If not provided, a new canvas will be created
+   * @param options.calculateSizeCallback - Optional callback function to calculate canvas size on window resize
+   * @param options.background - Optional background color as hex number (default: 0x000000)
+   */
   constructor(t = X) {
     const e = {
       ...X,
@@ -1728,28 +2550,64 @@ class le extends Nt {
       }
     ), this._missedImages = /* @__PURE__ */ new Map(), this._layoutViewManager = new Qt(), this.initialize(), this.onWindowResize(), this.animate(), this._isDirty = !0;
   }
+  /**
+   * Initializes the viewer after renderer and camera are created.
+   * 
+   * This method sets up the initial cursor and can be overridden by child classes
+   * to add custom initialization logic.
+   * 
+   * @protected
+   */
   initialize() {
     this.setCursor(C.Crosshair);
   }
   /**
+   * Gets the current view mode (selection or pan).
+   * 
+   * @returns The current view mode
    * @inheritdoc
    */
   get mode() {
     const t = this.activeLayoutView;
     return t ? t.mode : y.SELECTION;
   }
+  /**
+   * Sets the view mode (selection or pan).
+   * 
+   * @param value - The view mode to set
+   */
   set mode(t) {
     this.activeLayoutView.mode = t, this.editor.getPoint();
   }
+  /**
+   * Gets the Three.js renderer wrapper used for CAD rendering.
+   * 
+   * @returns The renderer instance
+   */
   get renderer() {
     return this._renderer;
   }
+  /**
+   * Gets whether the view needs to be re-rendered.
+   * 
+   * @returns True if the view is dirty and needs re-rendering
+   */
   get isDirty() {
     return this._isDirty;
   }
+  /**
+   * Sets whether the view needs to be re-rendered.
+   * 
+   * @param value - True to mark the view as needing re-rendering
+   */
   set isDirty(t) {
     this._isDirty = t;
   }
+  /**
+   * Gets information about missing data during rendering (fonts and images).
+   * 
+   * @returns Object containing maps of missing fonts and images
+   */
   get missedData() {
     return {
       fonts: this._renderer.missedFonts,
@@ -1988,9 +2846,30 @@ class le extends Nt {
 }
 const F = "simsun";
 class B {
+  /**
+   * Gets the singleton instance of the document creator.
+   * 
+   * @returns The singleton AcApDocCreator instance
+   */
   static get instance() {
     return B._instance || (B._instance = new B()), B._instance;
   }
+  /**
+   * Creates a simple example document with circular hatches.
+   * 
+   * This method generates a 2x2 grid of circular hatched areas,
+   * useful for testing hatch rendering and basic geometry display.
+   * 
+   * @param db - The database to add the example entities to
+   * 
+   * @example
+   * ```typescript
+   * const creator = AcApDocCreator.instance;
+   * const database = new AcDbDatabase();
+   * creator.createExampleDoc1(database);
+   * // Database now contains 4 circular hatches in a grid
+   * ```
+   */
   createExampleDoc1(t) {
     for (let n = 0; n < 2; ++n)
       for (let o = 0; o < 2; ++o) {
@@ -1998,6 +2877,28 @@ class B {
         a.addVertexAt(0, { x: o * 100, y: n * 100, bulge: 1 }), a.addVertexAt(1, { x: o * 100 + 100, y: n * 100, bulge: 1 }), a.closed = !0, r.add(a), t.tables.blockTable.modelSpace.appendEntity(r);
       }
   }
+  /**
+   * Creates a comprehensive example document with various CAD entities.
+   * 
+   * This method generates a more complex document containing:
+   * - Arcs and lines forming geometric shapes
+   * - Complex hatches with boundary loops
+   * - Formatted text (MText) with Chinese characters
+   * - Custom text styles
+   * 
+   * This example is useful for testing complex rendering scenarios,
+   * text handling, and international character support.
+   * 
+   * @param db - The database to add the example entities to
+   * 
+   * @example
+   * ```typescript
+   * const creator = AcApDocCreator.instance;
+   * const database = new AcDbDatabase();
+   * creator.createExampleDoc2(database);
+   * // Database now contains arcs, lines, hatches, and formatted text
+   * ```
+   */
   createExampleDoc2(t) {
     const e = t.tables.blockTable.modelSpace;
     e.appendEntity(this.createArc()), this.createLines().forEach((n) => {
@@ -2051,7 +2952,7 @@ class B {
   createLines() {
     const t = [];
     return t.push(
-      new M(
+      new L(
         {
           x: 11600.20888122753,
           y: 85279.57362051727,
@@ -2064,7 +2965,7 @@ class B {
         }
       )
     ), t.push(
-      new M(
+      new L(
         {
           x: 11600.20890652924,
           y: 86546.03982284805,
@@ -2077,7 +2978,7 @@ class B {
         }
       )
     ), t.push(
-      new M(
+      new L(
         {
           x: 10850.2088602169,
           y: 86546.03967292747,
@@ -2090,7 +2991,7 @@ class B {
         }
       )
     ), t.push(
-      new M(
+      new L(
         {
           x: 9050.208855839213,
           y: 86546.0397510943,
@@ -2103,7 +3004,7 @@ class B {
         }
       )
     ), t.push(
-      new M(
+      new L(
         {
           x: 8200.209067034302,
           y: 86546.039727177,
@@ -2119,6 +3020,11 @@ class B {
   }
 }
 class de {
+  /**
+   * Creates a new font loader instance.
+   * 
+   * @param renderer - The Three.js renderer that will use the loaded fonts
+   */
   constructor(t) {
     this._cadRenderer = t, this._avaiableFonts = [];
   }
@@ -2166,9 +3072,20 @@ class de {
   }
 }
 class w {
+  /**
+   * Private constructor for singleton pattern.
+   * 
+   * Creates an empty document with a 2D view and sets up the application context.
+   * Registers default commands and creates an example document.
+   * 
+   * @param canvas - Optional HTML canvas element for rendering. If not provided, a new canvas will be created
+   * @private
+   */
   constructor(t) {
     this.events = {
+      /** Fired when a new document is created */
       documentCreated: new m(),
+      /** Fired when a document becomes active */
       documentActivated: new m()
     };
     const e = new Pt();
@@ -2183,72 +3100,190 @@ class w {
       width: window.innerWidth,
       height: window.innerHeight - 30
     }), n = new le({ canvas: t, calculateSizeCallback: s });
-    this._context = new bt(n, e), this._fontLoader = new de(n.renderer), W().workingDatabase = e.database, this.registerCommands(), this.createExampleDoc();
-  }
+    this._context = new bt(n, e), this._fontLoader = new de(n.renderer), W().workingDatabase = e.database, this.registerCommands();
+  }
+  /**
+   * Creates the singleton instance with an optional canvas element.
+   * 
+   * This method should be called before accessing the `instance` property
+   * if you want to provide a specific canvas element.
+   * 
+   * @param canvas - Optional HTML canvas element for rendering
+   * @returns The singleton instance
+   * 
+   * @example
+   * ```typescript
+   * const canvas = document.getElementById('my-canvas') as HTMLCanvasElement;
+   * const docManager = AcApDocManager.createInstance(canvas);
+   * ```
+   */
   static createInstance(t) {
     return w._instance == null && (w._instance = new w(t)), this._instance;
   }
+  /**
+   * Gets the singleton instance of the document manager.
+   * 
+   * Creates a new instance if one doesn't exist yet.
+   * 
+   * @returns The singleton document manager instance
+   */
   static get instance() {
     return w._instance || (w._instance = new w()), w._instance;
   }
   /**
-   * Current context
+   * Gets the current application context.
+   * 
+   * The context binds the current document with its associated view.
+   * 
+   * @returns The current application context
    */
   get context() {
     return this._context;
   }
   /**
-   * Current open drawing
+   * Gets the currently open CAD document.
+   * 
+   * @returns The current document instance
    */
   get curDocument() {
     return this._context.doc;
   }
   /**
-   * For now, it is same as property `curDocument`.
+   * Gets the currently active document.
+   * 
+   * For now, this is the same as `curDocument` since only one document
+   * can be active at a time.
+   * 
+   * @returns The current active document
    */
   get mdiActiveDocument() {
     return this._context.doc;
   }
   /**
-   * Current view used to show current drawing
+   * Gets the current 2D view used to display the drawing.
+   * 
+   * @returns The current 2D view instance
    */
   get curView() {
     return this._context.view;
   }
+  /**
+   * Gets the editor instance for handling user input.
+   * 
+   * @returns The current editor instance
+   */
   get editor() {
     return this._context.view.editor;
   }
   /**
-   * Avaiable fonts to load. It means those fonts are avaiable to load. However, it
-   * doesn't mean those fonts are already loaded and avaiable to use.
+   * Gets the list of available fonts that can be loaded.
+   * 
+   * Note: These fonts are available for loading but may not be loaded yet.
+   * 
+   * @returns Array of available font names
    */
   get avaiableFonts() {
     return this._fontLoader.avaiableFonts;
   }
   /**
-   * Load the specified fonts
-   * @param fonts Input one list of font names
+   * Loads the specified fonts for text rendering.
+   * 
+   * @param fonts - Array of font names to load
+   * @returns Promise that resolves when fonts are loaded
+   * 
+   * @example
+   * ```typescript
+   * await docManager.loadFonts(['Arial', 'Times New Roman']);
+   * ```
    */
   async loadFonts(t) {
     await this._fontLoader.load(t);
   }
   /**
-   * Load default fonts
+   * Loads default fonts for CAD text rendering.
+   * 
+   * This method loads either the specified fonts or falls back to default Chinese fonts
+   * (specifically 'simkai') if no fonts are provided. The loaded fonts are used for
+   * rendering CAD text entities like MText and Text in the viewer.
+   * 
+   * It is better to load default fonts when viewer is initialized so that the viewer can
+   * render text correctly if fonts used in the document are not available.
+   * 
+   * @param fonts - Optional array of font names to load. If not provided or null, 
+   *               defaults to ['simkai'] for Chinese text support
+   * @returns Promise that resolves when all specified fonts are loaded
+   * 
+   * @example
+   * ```typescript
+   * // Load default fonts (simkai)
+   * await docManager.loadDefaultFonts();
+   * 
+   * // Load specific fonts
+   * await docManager.loadDefaultFonts(['Arial', 'SimSun']);
+   * 
+   * // Load no fonts (empty array)
+   * await docManager.loadDefaultFonts([]);
+   * ```
+   * 
+   * @see {@link AcApFontLoader.load} - The underlying font loading implementation
+   * @see {@link createExampleDoc} - Method that uses this for example document creation
+   */
+  async loadDefaultFonts(t) {
+    t == null ? await this._fontLoader.load(["simkai"]) : await this._fontLoader.load(t);
+  }
+  /**
+   * Creates an example CAD document with sample content.
+   * 
+   * This method asynchronously loads default fonts, creates example drawing content,
+   * sets up layout information, and zooms the view to fit the content.
+   * The creation is performed after a short delay to ensure proper initialization.
    */
-  async loadDefaultFonts() {
-    const t = ["simkai"];
-    await this._fontLoader.load(t);
-  }
   createExampleDoc() {
     setTimeout(async () => {
       await this.loadDefaultFonts(), B.instance.createExampleDoc2(this.curDocument.database), this.setLayoutInfo(), this.curView.zoomToFit();
     });
   }
+  /**
+   * Opens a CAD document from a URL.
+   * 
+   * This method loads a document from the specified URL and replaces the current document.
+   * It handles the complete document lifecycle including before/after open events.
+   * 
+   * @param url - The URL of the CAD file to open
+   * @param options - Optional database opening options. If not provided, default options with font loader will be used
+   * @returns Promise that resolves to true if the document was successfully opened, false otherwise
+   * 
+   * @example
+   * ```typescript
+   * const success = await docManager.openUrl('https://example.com/drawing.dwg');
+   * if (success) {
+   *   console.log('Document opened successfully');
+   * }
+   * ```
+   */
   async openUrl(t, e) {
     this.onBeforeOpenDocument(), e = this.setOptions(e);
     const s = await this.context.doc.openUri(t, e);
-    this.onAfterOpenDocument(s);
-  }
+    return this.onAfterOpenDocument(s), s;
+  }
+  /**
+   * Opens a CAD document from file content.
+   * 
+   * This method loads a document from the provided file content (string or binary data)
+   * and replaces the current document. It handles the complete document lifecycle
+   * including before/after open events.
+   * 
+   * @param fileName - The name of the file being opened (used for format detection)
+   * @param content - The file content as string or ArrayBuffer
+   * @param options - Database opening options including font loader settings
+   * @returns Promise that resolves to true if the document was successfully opened, false otherwise
+   * 
+   * @example
+   * ```typescript
+   * const fileContent = await file.arrayBuffer();
+   * const success = await docManager.openDocument('drawing.dwg', fileContent, options);
+   * ```
+   */
   async openDocument(t, e, s) {
     this.onBeforeOpenDocument(), s = this.setOptions(s);
     const n = await this.context.doc.openDocument(
@@ -2256,8 +3291,22 @@ class w {
       e,
       s
     );
-    this.onAfterOpenDocument(n);
-  }
+    return this.onAfterOpenDocument(n), n;
+  }
+  /**
+   * Registers all default commands available in the CAD viewer.
+   * 
+   * This method sets up the command system by registering built-in commands including:
+   * - pan: Pan/move the view
+   * - select: Select entities
+   * - zoom: Zoom in/out
+   * - zoomw: Zoom to window/box
+   * - csvg: Convert to SVG
+   * - qnew: Quick new document
+   * - open: Open document
+   * 
+   * All commands are registered under the system command group.
+   */
   registerCommands() {
     const t = _.instance;
     t.addCommand(
@@ -2297,21 +3346,72 @@ class w {
       new Vt()
     );
   }
+  /**
+   * Executes a command by its string name.
+   * 
+   * This method looks up a registered command by name and executes it with the current context.
+   * If the command is not found, no action is taken.
+   * 
+   * @param cmdStr - The command string to execute (e.g., 'pan', 'zoom', 'select')
+   * 
+   * @example
+   * ```typescript
+   * docManager.sendStringToExecute('zoom');
+   * docManager.sendStringToExecute('pan');
+   * ```
+   */
   sendStringToExecute(t) {
     const s = _.instance.lookupGlobalCmd(t);
     s == null || s.execute(this.context);
   }
+  /**
+   * Performs cleanup operations before opening a new document.
+   * 
+   * This protected method is called automatically before any document opening operation.
+   * It clears the current view to prepare for the new document content.
+   * 
+   * @protected
+   */
   onBeforeOpenDocument() {
     this.curView.clear();
   }
+  /**
+   * Performs setup operations after a document opening attempt.
+   * 
+   * This protected method is called automatically after any document opening operation.
+   * If the document was successfully opened, it dispatches the documentActivated event,
+   * sets up layout information, and zooms the view to fit the content.
+   * 
+   * @param isSuccess - Whether the document was successfully opened
+   * @protected
+   */
   onAfterOpenDocument(t) {
     t && (this.events.documentActivated.dispatch({
       doc: this.context.doc
     }), this.setLayoutInfo(), this.curView.zoomToFit());
   }
+  /**
+   * Sets up or validates database opening options.
+   * 
+   * This private method ensures that the options object has a font loader configured.
+   * If no options are provided, creates new options with the font loader.
+   * If options are provided but missing a font loader, adds the font loader.
+   * 
+   * @param options - Optional database opening options to validate/modify
+   * @returns The validated options object with font loader configured
+   * @private
+   */
   setOptions(t) {
     return t == null ? t = { fontLoader: this._fontLoader } : t.fontLoader == null && (t.fontLoader = this._fontLoader), t;
   }
+  /**
+   * Configures layout information for the current view.
+   * 
+   * This private method sets up the active layout block table record ID and
+   * model space block table record ID based on the current document's space configuration.
+   * 
+   * @private
+   */
   setLayoutInfo() {
     const t = this.curView;
     t.activeLayoutBtrId = this.curDocument.database.currentSpaceId, t.modelSpaceBtrId = this.curDocument.database.currentSpaceId;
@@ -2328,12 +3428,35 @@ const ue = {
 class I {
   constructor() {
     this.events = {
+      /** Fired when any setting is modified */
       modified: new m()
     };
   }
+  /**
+   * Gets the singleton instance of the settings manager.
+   * 
+   * Creates a new instance if one doesn't exist yet.
+   * 
+   * @returns The singleton settings manager instance
+   */
   static get instance() {
     return this._instance || (this._instance = new I()), this._instance;
   }
+  /**
+   * Sets a setting value and persists it to localStorage.
+   * 
+   * Fires a modified event after the setting is saved.
+   * 
+   * @template K - The setting key type
+   * @param key - The setting key to modify
+   * @param value - The new value for the setting
+   * 
+   * @example
+   * ```typescript
+   * settings.set('isShowToolbar', false);
+   * settings.set('fontMapping', { 'Arial': 'Helvetica' });
+   * ```
+   */
   set(t, e) {
     const s = this.settings;
     s[t] = e, localStorage.setItem(U, JSON.stringify(s)), this.events.modified.dispatch({
@@ -2341,53 +3464,155 @@ class I {
       value: e
     });
   }
+  /**
+   * Gets a setting value.
+   * 
+   * Returns the stored value or the default value if not set.
+   * 
+   * @template K - The setting key type
+   * @param key - The setting key to retrieve
+   * @returns The setting value
+   * 
+   * @example
+   * ```typescript
+   * const isDebug = settings.get('isDebug');
+   * const fontMapping = settings.get('fontMapping');
+   * ```
+   */
   get(t) {
     return this.settings[t];
   }
+  /**
+   * Toggles a boolean setting value.
+   * 
+   * Only works with boolean settings. The caller should ensure the setting is boolean.
+   * 
+   * @template K - The setting key type
+   * @param key - The boolean setting key to toggle
+   * 
+   * @example
+   * ```typescript
+   * settings.toggle('isDebug');        // false -> true
+   * settings.toggle('isShowToolbar');  // true -> false
+   * ```
+   */
   toggle(t) {
     const e = this.get(t);
     this.set(t, !e);
   }
+  /**
+   * Gets whether debug mode is enabled.
+   * 
+   * @returns True if debug mode is enabled
+   */
   get isDebug() {
     return this.get("isDebug");
   }
+  /**
+   * Sets whether debug mode is enabled.
+   * 
+   * @param value - True to enable debug mode
+   */
   set isDebug(t) {
     this.set("isDebug", t);
   }
+  /**
+   * Gets whether the command line is visible.
+   * 
+   * @returns True if command line should be shown
+   */
   get isShowCommandLine() {
     return this.get("isShowCommandLine");
   }
+  /**
+   * Sets whether the command line is visible.
+   * 
+   * @param value - True to show the command line
+   */
   set isShowCommandLine(t) {
     this.set("isShowCommandLine", t);
   }
+  /**
+   * Gets whether coordinate display is visible.
+   * 
+   * @returns True if coordinates should be displayed
+   */
   get isShowCoordinate() {
     return this.get("isShowCoordinate");
   }
+  /**
+   * Sets whether coordinate display is visible.
+   * 
+   * @param value - True to show coordinates
+   */
   set isShowCoordinate(t) {
     this.set("isShowCoordinate", t);
   }
+  /**
+   * Gets whether the toolbar is visible.
+   * 
+   * @returns True if toolbar should be shown
+   */
   get isShowToolbar() {
     return this.get("isShowToolbar");
   }
+  /**
+   * Sets whether the toolbar is visible.
+   * 
+   * @param value - True to show the toolbar
+   */
   set isShowToolbar(t) {
     this.set("isShowToolbar", t);
   }
+  /**
+   * Gets whether performance statistics are displayed.
+   * 
+   * @returns True if stats should be shown
+   */
   get isShowStats() {
     return this.get("isShowStats");
   }
+  /**
+   * Sets whether performance statistics are displayed.
+   * 
+   * @param value - True to show stats
+   */
   set isShowStats(t) {
     this.set("isShowStats", t);
   }
+  /**
+   * Gets the font mapping configuration.
+   * 
+   * @returns The current font mapping
+   */
   get fontMapping() {
     return this.get("fontMapping");
   }
+  /**
+   * Sets the font mapping configuration.
+   * 
+   * @param value - The new font mapping
+   */
   set fontMapping(t) {
     this.set("fontMapping", t);
   }
+  /**
+   * Sets a single font mapping entry.
+   * 
+   * @param originalFont - The original font name
+   * @param mappedFont - The replacement font name
+   */
   setFontMapping(t, e) {
     const s = this.get("fontMapping");
     s[t] = e, this.set("fontMapping", s);
   }
+  /**
+   * Gets the current settings object.
+   * 
+   * This method combines localStorage values with default values.
+   * 
+   * @returns The current settings object
+   */
   get settings() {
     const t = localStorage.getItem(U), e = t == null ? {} : JSON.parse(t);
     return _t(e, ue);
@@ -2410,8 +3635,8 @@ export {
   x as AcEdCommand,
   _ as AcEdCommandStack,
   C as AcEdCorsorType,
-  Mt as AcEdCursorManager,
-  Lt as AcEdJig,
+  Lt as AcEdCursorManager,
+  Et as AcEdJig,
   Ot as AcEdSelectionSet,
   y as AcEdViewMode,
   At as AcEditor,