@mlightcad/data-model 1.9.1 → 1.9.2

package/lib/misc/proxyGraphic/AcDbProxyGraphic.js

@@ -0,0 +1,1104 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { AcCmColor, AcCmColorMethod, AcCmColorUtil } from '@mlightcad/common';
+import { AcGeArea2d, AcGeCircArc3d, AcGeEllipseArc3d, AcGeMatrix3d, AcGePoint3d, AcGePolyline2d, AcGeVector3d, getOcsAngle, getOcsReferenceVector, TAU, transformOcsPointToWcs, transformWcsPointToOcs } from '@mlightcad/geometry-engine';
+import { AcGiLineWeight, AcGiMTextAttachmentPoint, AcGiMTextFlowDirection } from '@mlightcad/graphic-interface';
+import { ByBlock, ByLayer, DEFAULT_TEXT_STYLE } from '../AcDbConstants';
+import { RAW_COLOR_TYPE_ACI, RAW_COLOR_TYPE_BY_BLOCK, RAW_COLOR_TYPE_BY_LAYER, RAW_COLOR_TYPE_RGB } from '../AcDbMLeaderStyleColorCodec';
+import { AcDbProxyGraphicBitStream, AcDbProxyGraphicByteStream } from './AcDbProxyGraphicBinaryStream';
+/**
+ * Maximum number of bytes written to each DXF group code **310** chunk when
+ * exporting proxy graphics.
+ *
+ * AutoCAD splits large binary payloads into 127-byte hexadecimal records.
+ */
+export var ACDB_PROXY_GRAPHIC_CHUNK_SIZE = 127;
+/**
+ * Proxy-graphic command type codes defined by ODA and used by ezdxf.
+ *
+ * Each record in a proxy-graphic stream begins with an 8-byte header
+ * `(size, type)` followed by a type-specific payload. Attribute commands affect
+ * subsequent geometry; matrix commands push and pop a transform stack.
+ */
+export var AcDbProxyGraphicType;
+(function (AcDbProxyGraphicType) {
+    /** Axis-aligned bounding box extents (type code 1). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Extents"] = 1] = "Extents";
+    /** Circle defined by center, radius, and normal (type code 2). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Circle"] = 2] = "Circle";
+    /** Circle defined by three points (type code 3). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Circle3P"] = 3] = "Circle3P";
+    /** Circular arc defined by center, radius, normal, start vector, and sweep (type code 4). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["CircularArc"] = 4] = "CircularArc";
+    /** Circular arc defined by three points (type code 5). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["CircularArc3P"] = 5] = "CircularArc3P";
+    /** Open polyline or single-point entity (type code 6). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Polyline"] = 6] = "Polyline";
+    /** Closed polygon, optionally filled (type code 7). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Polygon"] = 7] = "Polygon";
+    /** Triangle mesh (type code 8). Not currently rendered. */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Mesh"] = 8] = "Mesh";
+    /** Faceted shell rendered as edge segments (type code 9). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Shell"] = 9] = "Shell";
+    /** Single-byte text primitive (type code 10). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Text"] = 10] = "Text";
+    /** Extended single-byte text primitive (type code 11). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Text2"] = 11] = "Text2";
+    /** Construction line through two points (type code 12). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Xline"] = 12] = "Xline";
+    /** Ray from a base point through a second point (type code 13). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["Ray"] = 13] = "Ray";
+    /** Sets the ACI color index for subsequent geometry (type code 14). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["AttributeColor"] = 14] = "AttributeColor";
+    /** Sets the layer by table index for subsequent geometry (type code 16). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["AttributeLayer"] = 16] = "AttributeLayer";
+    /** Sets the linetype by table index for subsequent geometry (type code 18). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["AttributeLinetype"] = 18] = "AttributeLinetype";
+    /** Marker attribute reserved by the format (type code 19). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["AttributeMarker"] = 19] = "AttributeMarker";
+    /** Enables or disables solid fill for the next polygon (type code 20). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["AttributeFill"] = 20] = "AttributeFill";
+    /** Sets true-color or special color encoding (type code 22). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["AttributeTrueColor"] = 22] = "AttributeTrueColor";
+    /** Sets lineweight for subsequent geometry (type code 23). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["AttributeLineweight"] = 23] = "AttributeLineweight";
+    /** Sets linetype scale for subsequent geometry (type code 24). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["AttributeLtscale"] = 24] = "AttributeLtscale";
+    /** Sets thickness for subsequent geometry (type code 25). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["AttributeThickness"] = 25] = "AttributeThickness";
+    /** Pushes a 4×4 transform matrix onto the matrix stack (type code 29). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["PushMatrix"] = 29] = "PushMatrix";
+    /** Pops the top transform matrix off the matrix stack (type code 31). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["PopMatrix"] = 31] = "PopMatrix";
+    /** Polyline with an appended normal vector (type code 32). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["PolylineWithNormals"] = 32] = "PolylineWithNormals";
+    /** Lightweight polyline encoded with DWG bit fields (type code 33). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["LwPolyline"] = 33] = "LwPolyline";
+    /** Unicode text primitive (type code 36). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["UnicodeText"] = 36] = "UnicodeText";
+    /** Extended Unicode text primitive (type code 38). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["UnicodeText2"] = 38] = "UnicodeText2";
+    /** Elliptical arc primitive (type code 44). */
+    AcDbProxyGraphicType[AcDbProxyGraphicType["EllipticArc"] = 44] = "EllipticArc";
+})(AcDbProxyGraphicType || (AcDbProxyGraphicType = {}));
+/** World Z axis used as the default entity normal. */
+var Z_AXIS = AcGeVector3d.Z_AXIS;
+/** Maximum raw lineweight value before sign extension is applied. */
+var MAX_VALID_LINEWEIGHT = 0x211;
+/**
+ * Decodes a packed 32-bit proxy-graphic color value into ACI or RGB parts.
+ *
+ * @param raw - Packed color dword from an {@link AcDbProxyGraphicType.AttributeTrueColor} chunk.
+ * @returns Decoded color index and/or 24-bit RGB value.
+ */
+function decodeProxyGraphicRawColor(raw) {
+    var type = (raw >> 24) & 0xff;
+    if (type === RAW_COLOR_TYPE_RGB) {
+        return { rgb: raw & 0xffffff };
+    }
+    if (type === RAW_COLOR_TYPE_BY_LAYER) {
+        return { colorIndex: 256 };
+    }
+    if (type === RAW_COLOR_TYPE_BY_BLOCK) {
+        return { colorIndex: 0 };
+    }
+    if (type === RAW_COLOR_TYPE_ACI) {
+        return { colorIndex: raw & 0xff };
+    }
+    return { colorIndex: raw & 0xff };
+}
+/**
+ * Converts a {@link AcGeVector3dLike} object to an {@link AcGeVector3d}.
+ *
+ * @param v - Input vector-like value.
+ * @returns A concrete 3D vector with `z` defaulting to `0` when omitted.
+ */
+function vectorFromLike(v) {
+    var _a;
+    return new AcGeVector3d(v.x, v.y, (_a = v.z) !== null && _a !== void 0 ? _a : 0);
+}
+/**
+ * Converts a {@link AcGePoint3dLike} object to an {@link AcGePoint3d}.
+ *
+ * @param p - Input point-like value.
+ * @returns A concrete 3D point with `z` defaulting to `0` when omitted.
+ */
+function pointFromLike(p) {
+    var _a;
+    return new AcGePoint3d(p.x, p.y, (_a = p.z) !== null && _a !== void 0 ? _a : 0);
+}
+/**
+ * Converts a numeric vertex tuple to a {@link AcGePoint3dLike} object.
+ *
+ * @param v - Vertex as `[x, y, z]`.
+ * @returns A point-like object suitable for geometry helpers.
+ */
+function vertexTuple(v) {
+    return { x: v[0], y: v[1], z: v[2] };
+}
+/**
+ * Decodes AutoCAD proxy-entity graphics binary data and renders primitives
+ * through {@link AcGiRenderer}.
+ *
+ * A proxy-graphic buffer is a sequence of length-prefixed chunks. Each chunk
+ * begins with a little-endian header `(size, type)` where `size` includes the
+ * 8-byte header itself. Geometry commands emit drawable entities; attribute
+ * commands update a lightweight graphics-state machine (color, layer, linetype,
+ * fill, and so on).
+ *
+ * The implementation follows the ODA proxy-graphic format used by ezdxf's
+ * `ProxyGraphic` module.
+ *
+ * @see {@link AcDbProxyEntity.subWorldDraw}
+ */
+var AcDbProxyGraphic = /** @class */ (function () {
+    /**
+     * Creates a proxy-graphic parser over the given byte stream.
+     *
+     * When a {@link AcDbDatabase} is supplied, layer and linetype tables are
+     * cached so attribute commands can resolve table indices to names.
+     *
+     * @param data - Raw proxy-graphic bytes from a proxy entity.
+     * @param options - Optional decoding and rendering context.
+     */
+    function AcDbProxyGraphic(data, options) {
+        if (options === void 0) { options = {}; }
+        var _this = this;
+        var _a, _b, _c;
+        /** Index of the first chunk header. Skips the 8-byte stream prefix. */
+        this._index = 8;
+        /** Current ACI color index for subsequent geometry. `256` means ByLayer. */
+        this._colorIndex = 256;
+        /** Current layer name for subsequent geometry. */
+        this._layer = '0';
+        /** Current linetype name for subsequent geometry. */
+        this._linetype = ByLayer;
+        /** Current lineweight for subsequent geometry. */
+        this._lineweight = AcGiLineWeight.ByLineWeightDefault;
+        /** Current linetype scale for subsequent geometry. */
+        this._ltscale = 1;
+        /** Current thickness for subsequent geometry. */
+        this._thickness = 0;
+        /** When `true`, the next {@link AcDbProxyGraphicType.Polygon} is filled. */
+        this._fill = false;
+        /** Layer names indexed by {@link AcDbProxyGraphicType.AttributeLayer} values. */
+        this._layers = [];
+        /** Linetype names indexed by {@link AcDbProxyGraphicType.AttributeLinetype} values. */
+        this._linetypes = [];
+        /** Active transform stack applied to decoded points and vectors. */
+        this._matrices = [];
+        this._buffer = data;
+        this._database = options.database;
+        this._dxfversion = (_a = options.dxfversion) !== null && _a !== void 0 ? _a : 'AC1015';
+        this._encoding =
+            (_b = options.encoding) !== null && _b !== void 0 ? _b : (this._dxfversion < 'AC1024' ? 'windows-1252' : 'utf-8');
+        this._layer = (_c = options.defaultLayer) !== null && _c !== void 0 ? _c : '0';
+        if (this._database) {
+            this._database.tables.layerTable
+                .newIterator()
+                .toArray()
+                .forEach(function (layer) { return _this._layers.push(layer.name); });
+            this._database.tables.linetypeTable
+                .newIterator()
+                .toArray()
+                .forEach(function (linetype) { return _this._linetypes.push(linetype.name); });
+        }
+    }
+    Object.defineProperty(AcDbProxyGraphic.prototype, "extents", {
+        /**
+         * Gets the most recently parsed extents corners.
+         *
+         * @returns Minimum and maximum corners from the last EXTENTS chunk, or
+         *   `undefined` when no extents chunk has been read.
+         */
+        get: function () {
+            return this._extents;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Scans the buffer for an {@link AcDbProxyGraphicType.Extents} chunk without
+     * rendering geometry.
+     *
+     * @returns The minimum and maximum corners when an EXTENTS chunk is found,
+     *   otherwise `undefined`.
+     */
+    AcDbProxyGraphic.prototype.scanExtents = function () {
+        var _a;
+        var buffer = this._buffer;
+        var index = this._index;
+        while (index < buffer.length) {
+            var headerView = new DataView(buffer.buffer, buffer.byteOffset + index, 8);
+            var size = headerView.getUint32(0, true);
+            var type = headerView.getUint32(4, true);
+            if (size < 8) {
+                break;
+            }
+            if (type === AcDbProxyGraphicType.Extents) {
+                var chunk = buffer.subarray(index + 8, index + size);
+                this.readExtents(chunk);
+                if (((_a = this._extents) === null || _a === void 0 ? void 0 : _a.length) === 2) {
+                    return [this._extents[0], this._extents[1]];
+                }
+                return undefined;
+            }
+            index += size;
+        }
+        return undefined;
+    };
+    /**
+     * Parses the full proxy-graphic stream and renders drawable primitives.
+     *
+     * Renderer sub-entity traits are saved before parsing and restored afterward
+     * so attribute commands do not leak state to the caller.
+     *
+     * @param renderer - Target graphics renderer.
+     * @returns A grouped {@link AcGiEntity} when at least one primitive was
+     *   emitted, otherwise `undefined`.
+     */
+    AcDbProxyGraphic.prototype.worldDraw = function (renderer) {
+        var entities = [];
+        var traits = renderer.subEntityTraits;
+        var previousTraits = {
+            color: traits.color.clone(),
+            rgbColor: traits.rgbColor,
+            lineType: traits.lineType,
+            lineTypeScale: traits.lineTypeScale,
+            lineWeight: traits.lineWeight,
+            layer: traits.layer,
+            thickness: traits.thickness
+        };
+        var buffer = this._buffer;
+        var index = this._index;
+        while (index < buffer.length) {
+            var headerView = new DataView(buffer.buffer, buffer.byteOffset + index, 8);
+            var size = headerView.getUint32(0, true);
+            var type = headerView.getUint32(4, true);
+            if (size < 8) {
+                break;
+            }
+            var chunk = buffer.subarray(index + 8, index + size);
+            this.dispatchChunk(renderer, entities, type, chunk);
+            if (type !== AcDbProxyGraphicType.AttributeFill) {
+                this._fill = false;
+            }
+            index += size;
+        }
+        traits.color = previousTraits.color;
+        traits.rgbColor = previousTraits.rgbColor;
+        traits.lineType = previousTraits.lineType;
+        traits.lineTypeScale = previousTraits.lineTypeScale;
+        traits.lineWeight = previousTraits.lineWeight;
+        traits.layer = previousTraits.layer;
+        traits.thickness = previousTraits.thickness;
+        if (entities.length === 0) {
+            return undefined;
+        }
+        return renderer.group(entities);
+    };
+    /**
+     * Dispatches a single proxy-graphic chunk to the appropriate handler.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param type - Chunk type code from {@link AcDbProxyGraphicType}.
+     * @param data - Chunk payload bytes excluding the 8-byte header.
+     */
+    AcDbProxyGraphic.prototype.dispatchChunk = function (renderer, entities, type, data) {
+        switch (type) {
+            case AcDbProxyGraphicType.Extents:
+                this.readExtents(data);
+                break;
+            case AcDbProxyGraphicType.Circle:
+                this.drawCircle(renderer, entities, data);
+                break;
+            case AcDbProxyGraphicType.Circle3P:
+                this.drawCircle3P(renderer, entities, data);
+                break;
+            case AcDbProxyGraphicType.CircularArc:
+                this.drawCircularArc(renderer, entities, data);
+                break;
+            case AcDbProxyGraphicType.CircularArc3P:
+                this.drawCircularArc3P(renderer, entities, data);
+                break;
+            case AcDbProxyGraphicType.EllipticArc:
+                this.drawEllipticArc(renderer, entities, data);
+                break;
+            case AcDbProxyGraphicType.Polyline:
+                this.drawPolyline(renderer, entities, data, false);
+                break;
+            case AcDbProxyGraphicType.PolylineWithNormals:
+                this.drawPolyline(renderer, entities, data, true);
+                break;
+            case AcDbProxyGraphicType.Polygon:
+                this.drawPolygon(renderer, entities, data);
+                break;
+            case AcDbProxyGraphicType.LwPolyline:
+                this.drawLwPolyline(renderer, entities, data);
+                break;
+            case AcDbProxyGraphicType.Shell:
+                this.drawShell(renderer, entities, data);
+                break;
+            case AcDbProxyGraphicType.Text:
+                this.drawText(renderer, entities, data, false);
+                break;
+            case AcDbProxyGraphicType.UnicodeText:
+                this.drawText(renderer, entities, data, true);
+                break;
+            case AcDbProxyGraphicType.Text2:
+                this.drawText2(renderer, entities, data, false);
+                break;
+            case AcDbProxyGraphicType.UnicodeText2:
+                this.drawText2(renderer, entities, data, true);
+                break;
+            case AcDbProxyGraphicType.Xline:
+                this.drawXline(renderer, entities, data, false);
+                break;
+            case AcDbProxyGraphicType.Ray:
+                this.drawXline(renderer, entities, data, true);
+                break;
+            case AcDbProxyGraphicType.AttributeColor:
+                this.readAttributeColor(data);
+                break;
+            case AcDbProxyGraphicType.AttributeLayer:
+                this.readAttributeLayer(data);
+                break;
+            case AcDbProxyGraphicType.AttributeLinetype:
+                this.readAttributeLinetype(data);
+                break;
+            case AcDbProxyGraphicType.AttributeFill:
+                this.readAttributeFill(data);
+                break;
+            case AcDbProxyGraphicType.AttributeTrueColor:
+                this.readAttributeTrueColor(data);
+                break;
+            case AcDbProxyGraphicType.AttributeLineweight:
+                this.readAttributeLineweight(data);
+                break;
+            case AcDbProxyGraphicType.AttributeLtscale:
+                this.readAttributeLtscale(data);
+                break;
+            case AcDbProxyGraphicType.AttributeThickness:
+                this.readAttributeThickness(data);
+                break;
+            case AcDbProxyGraphicType.PushMatrix:
+                this.pushMatrix(data);
+                break;
+            case AcDbProxyGraphicType.PopMatrix:
+                this.popMatrix();
+                break;
+            default:
+                break;
+        }
+    };
+    /**
+     * Applies the current proxy-graphic graphics state to renderer traits.
+     *
+     * @param renderer - Target graphics renderer whose {@link AcGiRenderer.subEntityTraits}
+     *   are updated in place.
+     */
+    AcDbProxyGraphic.prototype.applyTraits = function (renderer) {
+        var _a;
+        var traits = renderer.subEntityTraits;
+        traits.layer = this._layer;
+        traits.lineTypeScale = this._ltscale;
+        traits.thickness = this._thickness;
+        traits.lineWeight = this._lineweight;
+        if (this._rgbColor != null) {
+            traits.rgbColor = this._rgbColor;
+            traits.color = new AcCmColor(AcCmColorMethod.ByColor, this._rgbColor);
+        }
+        else if (this._colorIndex === 256) {
+            traits.color = new AcCmColor(AcCmColorMethod.ByLayer);
+            traits.rgbColor =
+                (_a = AcCmColorUtil.getColorByIndex(7)) !== null && _a !== void 0 ? _a : traits.rgbColor;
+        }
+        else if (this._colorIndex === 0) {
+            traits.color = new AcCmColor(AcCmColorMethod.ByBlock);
+        }
+        else {
+            var rgb = AcCmColorUtil.getColorByIndex(this._colorIndex);
+            traits.color = new AcCmColor(AcCmColorMethod.ByACI, this._colorIndex);
+            if (rgb != null) {
+                traits.rgbColor = rgb;
+            }
+        }
+        traits.lineType = {
+            name: this._linetype,
+            type: this.resolveLineStyleType(),
+            standardFlag: 0,
+            description: '',
+            totalPatternLength: 0
+        };
+    };
+    /**
+     * Maps the current linetype name to a renderer style-type enum value.
+     *
+     * @returns `'ByLayer'`, `'ByBlock'`, or `'UserSpecified'`.
+     */
+    AcDbProxyGraphic.prototype.resolveLineStyleType = function () {
+        if (this._linetype === ByLayer)
+            return 'ByLayer';
+        if (this._linetype === ByBlock)
+            return 'ByBlock';
+        return 'UserSpecified';
+    };
+    /**
+     * Applies the active matrix stack to a point.
+     *
+     * @param point - Source point in proxy-graphic coordinates.
+     * @returns The transformed {@link AcGePoint3d}.
+     */
+    AcDbProxyGraphic.prototype.transformPoint = function (point) {
+        var like = Array.isArray(point) ? vertexTuple(point) : point;
+        var transformed = pointFromLike(like);
+        if (this._matrices.length > 0) {
+            transformed.applyMatrix4(this._matrices[this._matrices.length - 1]);
+        }
+        return transformed;
+    };
+    /**
+     * Applies the active matrix stack to a direction vector and normalizes it.
+     *
+     * @param vector - Source vector in proxy-graphic coordinates.
+     * @returns The transformed unit vector.
+     */
+    AcDbProxyGraphic.prototype.transformVector = function (vector) {
+        var like = Array.isArray(vector) ? vertexTuple(vector) : vector;
+        var transformed = vectorFromLike(like);
+        if (this._matrices.length > 0) {
+            transformed.transformDirection(this._matrices[this._matrices.length - 1]);
+        }
+        return transformed.normalize();
+    };
+    /**
+     * Appends a drawable entity to the output list when defined.
+     *
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param entity - Entity returned by the renderer, if any.
+     */
+    AcDbProxyGraphic.prototype.pushEntity = function (entities, entity) {
+        if (entity) {
+            entities.push(entity);
+        }
+    };
+    /**
+     * Parses an {@link AcDbProxyGraphicType.Extents} chunk.
+     *
+     * @param data - Chunk payload containing minimum and maximum vertices.
+     */
+    AcDbProxyGraphic.prototype.readExtents = function (data) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var min = bs.readVertex();
+        var max = bs.readVertex();
+        this._extents = [
+            new AcGePoint3d(min[0], min[1], min[2]),
+            new AcGePoint3d(max[0], max[1], max[2])
+        ];
+    };
+    /**
+     * Parses an {@link AcDbProxyGraphicType.AttributeColor} chunk.
+     *
+     * @param data - Chunk payload containing a 32-bit ACI color index.
+     */
+    AcDbProxyGraphic.prototype.readAttributeColor = function (data) {
+        var value = new DataView(data.buffer, data.byteOffset, 4).getUint32(0, true);
+        this._rgbColor = undefined;
+        this._colorIndex = value > 256 || value < 0 ? 256 : value;
+    };
+    /**
+     * Parses an {@link AcDbProxyGraphicType.AttributeLayer} chunk.
+     *
+     * @param data - Chunk payload containing a layer-table index.
+     */
+    AcDbProxyGraphic.prototype.readAttributeLayer = function (data) {
+        var index = new DataView(data.buffer, data.byteOffset, 4).getUint32(0, true);
+        if (index < this._layers.length) {
+            this._layer = this._layers[index];
+        }
+    };
+    /**
+     * Parses an {@link AcDbProxyGraphicType.AttributeLinetype} chunk.
+     *
+     * @param data - Chunk payload containing a linetype-table index.
+     */
+    AcDbProxyGraphic.prototype.readAttributeLinetype = function (data) {
+        var index = new DataView(data.buffer, data.byteOffset, 4).getUint32(0, true);
+        if (index + 2 < this._linetypes.length) {
+            this._linetype = this._linetypes[index + 2];
+        }
+        else if (index === 32766) {
+            this._linetype = ByBlock;
+        }
+        else {
+            this._linetype = ByLayer;
+        }
+    };
+    /**
+     * Parses an {@link AcDbProxyGraphicType.AttributeFill} chunk.
+     *
+     * @param data - Chunk payload where any non-zero value enables fill.
+     */
+    AcDbProxyGraphic.prototype.readAttributeFill = function (data) {
+        this._fill = new DataView(data.buffer, data.byteOffset, 4).getUint32(0, true) !== 0;
+    };
+    /**
+     * Parses an {@link AcDbProxyGraphicType.AttributeTrueColor} chunk.
+     *
+     * @param data - Chunk payload containing a packed true-color dword.
+     */
+    AcDbProxyGraphic.prototype.readAttributeTrueColor = function (data) {
+        var raw = new DataView(data.buffer, data.byteOffset, 4).getUint32(0, true);
+        var decoded = decodeProxyGraphicRawColor(raw);
+        this._rgbColor = decoded.rgb;
+        if (decoded.colorIndex != null) {
+            this._colorIndex = decoded.colorIndex;
+        }
+    };
+    /**
+     * Parses an {@link AcDbProxyGraphicType.AttributeLineweight} chunk.
+     *
+     * @param data - Chunk payload containing a raw lineweight value.
+     */
+    AcDbProxyGraphic.prototype.readAttributeLineweight = function (data) {
+        var lw = new DataView(data.buffer, data.byteOffset, 4).getUint32(0, true);
+        if (lw > MAX_VALID_LINEWEIGHT) {
+            this._lineweight = (lw - 0x100000000);
+        }
+        else {
+            this._lineweight = lw;
+        }
+    };
+    /**
+     * Parses an {@link AcDbProxyGraphicType.AttributeLtscale} chunk.
+     *
+     * @param data - Chunk payload containing a little-endian double.
+     */
+    AcDbProxyGraphic.prototype.readAttributeLtscale = function (data) {
+        this._ltscale = new DataView(data.buffer, data.byteOffset, 8).getFloat64(0, true);
+    };
+    /**
+     * Parses an {@link AcDbProxyGraphicType.AttributeThickness} chunk.
+     *
+     * @param data - Chunk payload containing a little-endian double.
+     */
+    AcDbProxyGraphic.prototype.readAttributeThickness = function (data) {
+        this._thickness = new DataView(data.buffer, data.byteOffset, 8).getFloat64(0, true);
+    };
+    /**
+     * Parses a {@link AcDbProxyGraphicType.PushMatrix} chunk and pushes the
+     * decoded matrix onto the transform stack.
+     *
+     * @param data - Chunk payload containing 16 little-endian doubles.
+     */
+    AcDbProxyGraphic.prototype.pushMatrix = function (data) {
+        var values = new Float64Array(data.buffer, data.byteOffset, 16);
+        var matrix = new AcGeMatrix3d().fromArray(Array.from(values));
+        matrix.transpose();
+        this._matrices.push(matrix);
+    };
+    /**
+     * Pops the top matrix from the transform stack when the stack is non-empty.
+     */
+    AcDbProxyGraphic.prototype.popMatrix = function () {
+        if (this._matrices.length > 0) {
+            this._matrices.pop();
+        }
+    };
+    /**
+     * Reads a vertex list from a polyline-style chunk.
+     *
+     * @param data - Chunk payload beginning with a vertex count.
+     * @param loadNormal - When `true`, the final vertex is interpreted as a normal vector.
+     * @returns Decoded vertices and the extracted normal (defaults to Z axis).
+     */
+    AcDbProxyGraphic.prototype.loadVertices = function (data, loadNormal) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var count = bs.readLong();
+        if (loadNormal) {
+            count += 1;
+        }
+        var vertices = [];
+        while (count > 0) {
+            var _a = __read(bs.readVertex(), 3), x = _a[0], y = _a[1], z = _a[2];
+            vertices.push(this.transformPoint({ x: x, y: y, z: z }));
+            count -= 1;
+        }
+        var normal = Z_AXIS;
+        if (loadNormal && vertices.length > 0) {
+            normal = vectorFromLike(vertices.pop());
+        }
+        return { vertices: vertices, normal: normal };
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.Circle} chunk.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload.
+     */
+    AcDbProxyGraphic.prototype.drawCircle = function (renderer, entities, data) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var center = bs.readVertex();
+        var radius = bs.readFloat();
+        var normalVec = this.transformVector(bs.readVertex());
+        var centerPoint = pointFromLike({ x: center[0], y: center[1], z: center[2] });
+        if (!normalVec.equals(Z_AXIS)) {
+            centerPoint = transformWcsPointToOcs(centerPoint, normalVec);
+        }
+        centerPoint = this.transformPoint(centerPoint);
+        var refVec = getOcsReferenceVector(normalVec);
+        var arc = new AcGeCircArc3d(transformOcsPointToWcs(centerPoint, normalVec), radius, 0, TAU, normalVec, refVec);
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.circularArc(arc));
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.Circle3P} chunk.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload containing three perimeter points.
+     */
+    AcDbProxyGraphic.prototype.drawCircle3P = function (renderer, entities, data) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var p1 = this.transformPoint(bs.readVertex());
+        var p2 = this.transformPoint(bs.readVertex());
+        var p3 = this.transformPoint(bs.readVertex());
+        var center = AcGeCircArc3d.computeCenterPoint(p1, p2, p3);
+        if (!center)
+            return;
+        var radius = center.distanceTo(p1);
+        var arc = new AcGeCircArc3d(center, radius, 0, TAU, Z_AXIS);
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.circularArc(arc));
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.CircularArc} chunk.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload.
+     */
+    AcDbProxyGraphic.prototype.drawCircularArc = function (renderer, entities, data) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var center = bs.readVertex();
+        var radius = bs.readFloat();
+        var normal = bs.readVertex();
+        var startVec = bs.readVertex();
+        var sweepAngle = bs.readFloat();
+        var normalVec = this.transformVector(normal);
+        var centerWcs = pointFromLike({
+            x: center[0],
+            y: center[1],
+            z: center[2]
+        });
+        var refVec = this.transformVector(startVec).normalize();
+        var startAngle = 0;
+        var endAngle = sweepAngle;
+        var arc = new AcGeCircArc3d(this.transformPoint(centerWcs), radius, startAngle, endAngle, normalVec, refVec);
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.circularArc(arc));
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.CircularArc3P} chunk.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload containing start, middle, and end points.
+     */
+    AcDbProxyGraphic.prototype.drawCircularArc3P = function (renderer, entities, data) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var p1 = this.transformPoint(bs.readVertex());
+        var p2 = this.transformPoint(bs.readVertex());
+        var p3 = this.transformPoint(bs.readVertex());
+        var center = AcGeCircArc3d.computeCenterPoint(p1, p3, p2);
+        if (!center)
+            return;
+        var radius = center.distanceTo(p1);
+        var startAngle = getOcsAngle(center, p1, Z_AXIS);
+        var endAngle = getOcsAngle(center, p3, Z_AXIS);
+        var arc = new AcGeCircArc3d(center, radius, startAngle, endAngle, Z_AXIS);
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.circularArc(arc));
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.EllipticArc} chunk.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload.
+     */
+    AcDbProxyGraphic.prototype.drawEllipticArc = function (renderer, entities, data) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var center = this.transformPoint(bs.readVertex());
+        var extrusion = this.transformVector(bs.readVertex());
+        var majorAxisLength = bs.readFloat();
+        var minorAxisLength = bs.readFloat();
+        var startParam = bs.readFloat();
+        var endParam = bs.readFloat();
+        var majorAxisAngle = bs.readFloat();
+        var majorAxis = transformOcsPointToWcs({
+            x: Math.cos(majorAxisAngle) * majorAxisLength,
+            y: Math.sin(majorAxisAngle) * majorAxisLength,
+            z: 0
+        }, extrusion);
+        var ellipse = new AcGeEllipseArc3d(center, extrusion, majorAxis, majorAxisLength, minorAxisLength, startParam, endParam);
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.ellipticalArc(ellipse));
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.Polyline} or
+     * {@link AcDbProxyGraphicType.PolylineWithNormals} chunk.
+     *
+     * A single vertex is rendered as a point entity using database `pdmode` and
+     * `pdsize` settings when available.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload.
+     * @param _loadNormal - When `true`, the final vertex stores the polyline normal.
+     */
+    AcDbProxyGraphic.prototype.drawPolyline = function (renderer, entities, data, _loadNormal) {
+        var _a, _b, _c, _d;
+        var vertices = this.loadVertices(data, _loadNormal).vertices;
+        if (vertices.length === 0)
+            return;
+        if (vertices.length === 1) {
+            this.applyTraits(renderer);
+            var pdmode = (_b = (_a = this._database) === null || _a === void 0 ? void 0 : _a.pdmode) !== null && _b !== void 0 ? _b : 0;
+            var pdsize = (_d = (_c = this._database) === null || _c === void 0 ? void 0 : _c.pdsize) !== null && _d !== void 0 ? _d : 0;
+            this.pushEntity(entities, renderer.point(vertices[0], { displayMode: pdmode, displaySize: pdsize }));
+            return;
+        }
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.lines(vertices));
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.Polygon} chunk.
+     *
+     * When {@link AcDbProxyGraphicType.AttributeFill} was set for this polygon, a
+     * solid filled area is emitted; otherwise the polygon outline is drawn as a
+     * closed polyline.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload.
+     */
+    AcDbProxyGraphic.prototype.drawPolygon = function (renderer, entities, data) {
+        var vertices = this.loadVertices(data, false).vertices;
+        if (vertices.length < 2)
+            return;
+        if (this._fill) {
+            var polyline = new AcGePolyline2d(vertices.map(function (vertex) { return ({ x: vertex.x, y: vertex.y }); }), true);
+            var area = new AcGeArea2d();
+            area.add(polyline);
+            var traits = renderer.subEntityTraits;
+            traits.fillType = {
+                solidFill: true,
+                patternAngle: 0,
+                definitionLines: []
+            };
+            traits.drawOrder = -1;
+            this.applyTraits(renderer);
+            this.pushEntity(entities, renderer.area(area));
+            return;
+        }
+        var closed = __spreadArray(__spreadArray([], __read(vertices), false), [vertices[0]], false);
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.lines(closed));
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.LwPolyline} chunk.
+     *
+     * Bulge values are consumed but arc segments are not yet expanded; the result
+     * is a vertex polyline in the current transform stack.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Bit-packed chunk payload.
+     */
+    AcDbProxyGraphic.prototype.drawLwPolyline = function (renderer, entities, data) {
+        var bs = new AcDbProxyGraphicBitStream(data, this._dxfversion, this._encoding);
+        var elevation = 0;
+        var isClosed = false;
+        bs.readUnsignedLong();
+        var flag = bs.readBitShort();
+        if (flag & 8) {
+            elevation = bs.readBitDouble();
+        }
+        if (flag & 512) {
+            isClosed = true;
+        }
+        var numPoints = bs.readBitLong();
+        if (numPoints <= 0)
+            return;
+        var numBulges = flag & 16 ? bs.readBitLong() : 0;
+        if (this._dxfversion >= 'AC1024') {
+            if (flag & 1024) {
+                bs.readBitLong();
+            }
+            if (flag & 32) {
+                bs.readBitLong();
+            }
+        }
+        var rawVertices = bs.readRawDouble(2);
+        var vertices = [
+            this.transformPoint({ x: rawVertices[0], y: rawVertices[1], z: elevation })
+        ];
+        var prev = rawVertices;
+        for (var i = 1; i < numPoints; i++) {
+            var x = bs.readBitDoubleDefault(1, prev[0]);
+            var y = bs.readBitDoubleDefault(1, prev[1]);
+            prev = [x, y];
+            vertices.push(this.transformPoint({ x: x, y: y, z: elevation }));
+        }
+        for (var i = 0; i < numBulges; i++) {
+            bs.readBitDouble();
+        }
+        if (isClosed && vertices.length > 1) {
+            vertices.push(vertices[0].clone());
+        }
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.lines(vertices));
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.Shell} chunk as face edge segments.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload containing vertices and face index lists.
+     */
+    AcDbProxyGraphic.prototype.drawShell = function (renderer, entities, data) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var totalVertexCount = bs.readLong();
+        var vertices = [];
+        for (var i = 0; i < totalVertexCount; i++) {
+            var _a = __read(bs.readVertex(), 3), x = _a[0], y = _a[1], z = _a[2];
+            vertices.push(this.transformPoint({ x: x, y: y, z: z }));
+        }
+        var faceEntryCount = bs.readLong();
+        var lines = [];
+        var readCount = 0;
+        while (readCount < faceEntryCount) {
+            var edgeCount = Math.abs(bs.readSignedLong());
+            readCount += 1 + edgeCount;
+            var faceIndices = [];
+            for (var i = 0; i < edgeCount; i++) {
+                faceIndices.push(bs.readLong());
+            }
+            var faceVertices = faceIndices
+                .map(function (index) { return vertices[index]; })
+                .filter(Boolean);
+            if (faceVertices.length >= 3) {
+                for (var i = 0; i < faceVertices.length; i++) {
+                    lines.push(faceVertices[i]);
+                    lines.push(faceVertices[(i + 1) % faceVertices.length]);
+                }
+            }
+        }
+        if (lines.length === 0)
+            return;
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.lines(lines));
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.Text} or
+     * {@link AcDbProxyGraphicType.UnicodeText} chunk.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload.
+     * @param unicode - When `true`, text is decoded as UTF-16LE.
+     */
+    AcDbProxyGraphic.prototype.drawText = function (renderer, entities, data, unicode) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var insert = this.transformPoint(bs.readVertex());
+        var normal = this.transformVector(bs.readVertex());
+        var textDirection = this.transformVector(bs.readVertex());
+        var _a = __read(bs.readStruct([
+            8,
+            8,
+            8
+        ]), 3), height = _a[0], widthFactor = _a[1], obliqueAngle = _a[2];
+        var text = unicode
+            ? bs.readPaddedUnicodeString()
+            : bs.readPaddedString(this._encoding);
+        this.drawTextPrimitive(renderer, entities, {
+            insert: insert,
+            normal: normal,
+            textDirection: textDirection,
+            text: text,
+            height: height,
+            widthFactor: widthFactor,
+            obliqueAngle: obliqueAngle
+        });
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.Text2} or
+     * {@link AcDbProxyGraphicType.UnicodeText2} chunk.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload with extended text header fields.
+     * @param unicode - When `true`, text is decoded as UTF-16LE.
+     */
+    AcDbProxyGraphic.prototype.drawText2 = function (renderer, entities, data, unicode) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var insert = this.transformPoint(bs.readVertex());
+        var normal = this.transformVector(bs.readVertex());
+        var textDirection = this.transformVector(bs.readVertex());
+        var text = unicode
+            ? bs.readPaddedUnicodeString()
+            : bs.readPaddedString(this._encoding);
+        bs.readSignedLong();
+        bs.readSignedLong();
+        var _a = __read(bs.readStruct([
+            8,
+            8,
+            8
+        ]), 3), height = _a[0], widthFactor = _a[1], obliqueAngle = _a[2];
+        bs.readFloat();
+        this.drawTextPrimitive(renderer, entities, {
+            insert: insert,
+            normal: normal,
+            textDirection: textDirection,
+            text: text,
+            height: height,
+            widthFactor: widthFactor,
+            obliqueAngle: obliqueAngle
+        });
+    };
+    /**
+     * Emits a proxy-graphic text command as an {@link AcGiRenderer.mtext} entity.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param options - Parsed text placement and formatting values.
+     */
+    AcDbProxyGraphic.prototype.drawTextPrimitive = function (renderer, entities, options) {
+        var rotation = Math.atan2(options.textDirection.y, options.textDirection.x);
+        var mtextData = {
+            text: options.text,
+            height: options.height,
+            width: Infinity,
+            widthFactor: options.widthFactor,
+            position: options.insert,
+            rotation: (rotation * 180) / Math.PI,
+            drawingDirection: AcGiMTextFlowDirection.BOTTOM_TO_TOP,
+            attachmentPoint: AcGiMTextAttachmentPoint.BaselineLeft
+        };
+        var style = {
+            name: DEFAULT_TEXT_STYLE,
+            standardFlag: 0,
+            fixedTextHeight: 0,
+            widthFactor: options.widthFactor,
+            obliqueAngle: (options.obliqueAngle * 180) / Math.PI,
+            textGenerationFlag: 0,
+            lastHeight: options.height,
+            font: 'txt',
+            bigFont: ''
+        };
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.mtext(mtextData, style));
+    };
+    /**
+     * Renders an {@link AcDbProxyGraphicType.Xline} or
+     * {@link AcDbProxyGraphicType.Ray} chunk as a long screen-space segment.
+     *
+     * @param renderer - Target graphics renderer.
+     * @param entities - Accumulator for emitted drawable entities.
+     * @param data - Chunk payload containing two defining points.
+     * @param isRay - When `true`, the line starts at the first point; otherwise it
+     *   extends infinitely in both directions.
+     */
+    AcDbProxyGraphic.prototype.drawXline = function (renderer, entities, data, isRay) {
+        var bs = new AcDbProxyGraphicByteStream(data);
+        var start = this.transformPoint(bs.readVertex());
+        var other = this.transformPoint(bs.readVertex());
+        var direction = new AcGeVector3d().subVectors(other, start);
+        if (direction.lengthSq() === 0)
+            return;
+        var far = 1e6;
+        var end = isRay
+            ? start.clone().add(direction.normalize().multiplyScalar(far))
+            : start.clone().sub(direction.normalize().multiplyScalar(far));
+        var farEnd = other.clone().add(direction.normalize().multiplyScalar(far));
+        this.applyTraits(renderer);
+        this.pushEntity(entities, renderer.lines([end, farEnd]));
+    };
+    return AcDbProxyGraphic;
+}());
+export { AcDbProxyGraphic };
+/**
+ * Loads proxy-graphic bytes from DXF group codes **160** and **310**.
+ *
+ * Hex chunks are concatenated in order and optionally truncated to the declared
+ * byte length from group code **160**.
+ *
+ * @param length - Expected byte length from group code **160**.
+ * @param hexChunks - One or more hexadecimal strings from group code **310**.
+ * @returns Decoded bytes, or `undefined` when no hex chunks are supplied.
+ */
+export function loadAcDbProxyGraphicFromDxf(length, hexChunks) {
+    var e_1, _a;
+    if (!(hexChunks === null || hexChunks === void 0 ? void 0 : hexChunks.length)) {
+        return undefined;
+    }
+    var bytes = new Uint8Array(hexChunks.reduce(function (sum, chunk) { return sum + Math.floor(chunk.length / 2); }, 0));
+    var offset = 0;
+    try {
+        for (var hexChunks_1 = __values(hexChunks), hexChunks_1_1 = hexChunks_1.next(); !hexChunks_1_1.done; hexChunks_1_1 = hexChunks_1.next()) {
+            var chunk = hexChunks_1_1.value;
+            for (var i = 0; i < chunk.length; i += 2) {
+                bytes[offset++] = parseInt(chunk.slice(i, i + 2), 16);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (hexChunks_1_1 && !hexChunks_1_1.done && (_a = hexChunks_1.return)) _a.call(hexChunks_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (length != null && length > 0 && bytes.length >= length) {
+        return bytes.subarray(0, length);
+    }
+    return bytes;
+}
+//# sourceMappingURL=AcDbProxyGraphic.js.map