@mlightcad/data-model 1.14.10 → 1.14.12

package/lib/entity/AcDbArcAlignedText.js

@@ -0,0 +1,879 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 } from '@mlightcad/common';
+import { AcGeBox3d, AcGeMatrix3d, AcGePoint3d, AcGeVector3d } from '@mlightcad/geometry-engine';
+import { AcGiMTextAttachmentPoint, AcGiMTextFlowDirection } from '@mlightcad/graphic-interface';
+import { DEFAULT_TEXT_STYLE } from '../misc/AcDbConstants';
+import { AcDbEntity } from './AcDbEntity';
+import { acdbEstimatePlainTextWidth } from './AcDbTextExtentsHelpers';
+/**
+ * How characters are distributed between the arc's left and right offsets.
+ *
+ * Values match DXF group 72 / LibreDWG `alignment`:
+ * 1 fit, 2 left, 3 right, 4 center.
+ */
+export var AcDbArcTextAlignment;
+(function (AcDbArcTextAlignment) {
+    AcDbArcTextAlignment[AcDbArcTextAlignment["Fit"] = 1] = "Fit";
+    AcDbArcTextAlignment[AcDbArcTextAlignment["Left"] = 2] = "Left";
+    AcDbArcTextAlignment[AcDbArcTextAlignment["Right"] = 3] = "Right";
+    AcDbArcTextAlignment[AcDbArcTextAlignment["Center"] = 4] = "Center";
+})(AcDbArcTextAlignment || (AcDbArcTextAlignment = {}));
+/**
+ * Which way the glyph "up" direction points relative to the arc center.
+ *
+ * Values match DXF group 71: 1 outward from center, 2 inward to the center.
+ */
+export var AcDbArcTextDirection;
+(function (AcDbArcTextDirection) {
+    AcDbArcTextDirection[AcDbArcTextDirection["OutwardFromCenter"] = 1] = "OutwardFromCenter";
+    AcDbArcTextDirection[AcDbArcTextDirection["InwardToTheCenter"] = 2] = "InwardToTheCenter";
+})(AcDbArcTextDirection || (AcDbArcTextDirection = {}));
+/**
+ * Which side of the reference arc the text sits on.
+ *
+ * Values match DXF group 73: 1 convex (outside), 2 concave (inside).
+ */
+export var AcDbArcTextPosition;
+(function (AcDbArcTextPosition) {
+    AcDbArcTextPosition[AcDbArcTextPosition["OnConvexSide"] = 1] = "OnConvexSide";
+    AcDbArcTextPosition[AcDbArcTextPosition["OnConcaveSide"] = 2] = "OnConcaveSide";
+})(AcDbArcTextPosition || (AcDbArcTextPosition = {}));
+var TWO_PI = Math.PI * 2;
+function parseFinite(value, fallback) {
+    var n = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(n) ? n : fallback;
+}
+/**
+ * Arc-aligned text created by the AutoCAD Express Tools `ARCTEXT` command.
+ *
+ * This is not `AcDbText`. The string is laid out along an arc
+ * (center, radius, start angle, end angle), one glyph at a time, with its
+ * baseline following the arc tangent.
+ */
+var AcDbArcAlignedText = /** @class */ (function (_super) {
+    __extends(AcDbArcAlignedText, _super);
+    function AcDbArcAlignedText() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this._textString = '';
+        _this._textSize = 0;
+        _this._xScale = 1;
+        _this._characterSpacing = 0;
+        _this._styleName = '';
+        _this._fontName = '';
+        _this._bigFontName = '';
+        _this._offsetFromArc = 0;
+        _this._rightOffset = 0;
+        _this._leftOffset = 0;
+        _this._center = new AcGePoint3d();
+        _this._radius = 0;
+        _this._startAngle = 0;
+        _this._endAngle = 0;
+        _this._normal = new AcGeVector3d(0, 0, 1);
+        _this._characterSet = 0;
+        _this._pitchAndFamily = 0;
+        _this._isShx = false;
+        _this._isBold = false;
+        _this._isItalic = false;
+        _this._isUnderlined = false;
+        _this._alignment = AcDbArcTextAlignment.Fit;
+        _this._isReverse = false;
+        _this._wizardFlag = 0;
+        _this._textPosition = AcDbArcTextPosition.OnConvexSide;
+        _this._textDirection = AcDbArcTextDirection.OutwardFromCenter;
+        _this._arcId = '';
+        return _this;
+    }
+    Object.defineProperty(AcDbArcAlignedText.prototype, "dxfTypeName", {
+        get: function () {
+            return 'ARCALIGNEDTEXT';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "textString", {
+        get: function () {
+            return this._textString;
+        },
+        set: function (value) {
+            this._textString = value !== null && value !== void 0 ? value : '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "textSize", {
+        /** Text height (DXF group 42). */
+        get: function () {
+            return this._textSize;
+        },
+        set: function (value) {
+            this._textSize = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "xScale", {
+        /** Width factor (DXF group 41). */
+        get: function () {
+            return this._xScale;
+        },
+        set: function (value) {
+            this._xScale = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "characterSpacing", {
+        /** Extra distance inserted between characters, in drawing units. */
+        get: function () {
+            return this._characterSpacing;
+        },
+        set: function (value) {
+            this._characterSpacing = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "styleName", {
+        get: function () {
+            return this._styleName;
+        },
+        set: function (value) {
+            this._styleName = value !== null && value !== void 0 ? value : '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "fontName", {
+        get: function () {
+            return this._fontName;
+        },
+        set: function (value) {
+            this._fontName = value !== null && value !== void 0 ? value : '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "bigFontName", {
+        get: function () {
+            return this._bigFontName;
+        },
+        set: function (value) {
+            this._bigFontName = value !== null && value !== void 0 ? value : '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "offsetFromArc", {
+        /** Radial distance from the reference arc to the text baseline. */
+        get: function () {
+            return this._offsetFromArc;
+        },
+        set: function (value) {
+            this._offsetFromArc = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "rightOffset", {
+        get: function () {
+            return this._rightOffset;
+        },
+        set: function (value) {
+            this._rightOffset = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "leftOffset", {
+        get: function () {
+            return this._leftOffset;
+        },
+        set: function (value) {
+            this._leftOffset = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "center", {
+        /** Arc center in OCS (DXF group 10). */
+        get: function () {
+            return this._center;
+        },
+        set: function (value) {
+            this._center.copy(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "radius", {
+        get: function () {
+            return this._radius;
+        },
+        set: function (value) {
+            this._radius = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "startAngle", {
+        get: function () {
+            return this._startAngle;
+        },
+        set: function (value) {
+            this._startAngle = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "endAngle", {
+        get: function () {
+            return this._endAngle;
+        },
+        set: function (value) {
+            this._endAngle = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "normal", {
+        get: function () {
+            return this._normal;
+        },
+        set: function (value) {
+            this._normal.copy(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "characterSet", {
+        get: function () {
+            return this._characterSet;
+        },
+        set: function (value) {
+            this._characterSet = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "pitchAndFamily", {
+        get: function () {
+            return this._pitchAndFamily;
+        },
+        set: function (value) {
+            this._pitchAndFamily = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "isShx", {
+        get: function () {
+            return this._isShx;
+        },
+        set: function (value) {
+            this._isShx = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "isBold", {
+        get: function () {
+            return this._isBold;
+        },
+        set: function (value) {
+            this._isBold = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "isItalic", {
+        get: function () {
+            return this._isItalic;
+        },
+        set: function (value) {
+            this._isItalic = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "isUnderlined", {
+        get: function () {
+            return this._isUnderlined;
+        },
+        set: function (value) {
+            this._isUnderlined = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "alignment", {
+        get: function () {
+            return this._alignment;
+        },
+        set: function (value) {
+            this._alignment = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "isReverse", {
+        get: function () {
+            return this._isReverse;
+        },
+        set: function (value) {
+            this._isReverse = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "wizardFlag", {
+        get: function () {
+            return this._wizardFlag;
+        },
+        set: function (value) {
+            this._wizardFlag = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "textPosition", {
+        get: function () {
+            return this._textPosition;
+        },
+        set: function (value) {
+            this._textPosition = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "textDirection", {
+        get: function () {
+            return this._textDirection;
+        },
+        set: function (value) {
+            this._textDirection = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "arcId", {
+        /** Handle of the arc this text was created from (DXF group 330). */
+        get: function () {
+            return this._arcId;
+        },
+        set: function (value) {
+            this._arcId = value !== null && value !== void 0 ? value : '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Applies the arc-text color (DXF group 90 / LibreDWG `color`).
+     *
+     * `0` is ByBlock, `256` is ByLayer, `1..255` is an ACI index. Larger values
+     * are treated as a CMC color whose high byte is the method.
+     */
+    AcDbArcAlignedText.prototype.applyRawTextColor = function (raw) {
+        if (!Number.isFinite(raw))
+            return;
+        var color = new AcCmColor();
+        var method = (raw >>> 24) & 0xff;
+        if (raw === 0 || method === 0xc1) {
+            color.setByBlock();
+        }
+        else if (raw === 256 || method === 0xc0 || method === 0xc8) {
+            color.setByLayer();
+        }
+        else if (raw > 0 && raw < 256) {
+            color.colorIndex = raw;
+        }
+        else if (method === 0xc2 || method === 0xc3 || method === 0xc5) {
+            color.setRGBValue(raw & 0xffffff);
+        }
+        else {
+            return;
+        }
+        this._rawTextColor = raw;
+        this.color = color;
+    };
+    /**
+     * Encodes the entity color as DXF group 90 / LibreDWG `rawTextColor`.
+     *
+     * Prefers the last value passed to {@link applyRawTextColor} so DWG→DXF
+     * round-trips keep the original packed form.
+     */
+    AcDbArcAlignedText.prototype.rawTextColor = function () {
+        if (this._rawTextColor != null && Number.isFinite(this._rawTextColor)) {
+            return this._rawTextColor;
+        }
+        if (this.color.isByBlock)
+            return 0;
+        if (this.color.isByLayer)
+            return 256;
+        var aci = this.color.colorIndex;
+        if (aci != null && aci > 0 && aci < 256)
+            return aci;
+        var rgb = this.color.RGB;
+        if (rgb != null)
+            return ((0xc2 << 24) | (rgb & 0xffffff)) >> 0;
+        return 256;
+    };
+    /**
+     * Places each character on the reference arc.
+     *
+     * The arc runs counter-clockwise from {@link startAngle} to {@link endAngle}.
+     * {@link offsetFromArc} is the gap to the nearest text edge. Inward text
+     * sits with its baseline one text height farther from the center.
+     */
+    AcDbArcAlignedText.prototype.glyphPlacements = function () {
+        var _a, _b;
+        var chars = Array.from(this._textString).filter(function (ch) { return ch !== '\r'; });
+        if (this._isReverse)
+            chars.reverse();
+        if (chars.length === 0)
+            return [];
+        var height = this._textSize > 0 ? this._textSize : 1;
+        var widthFactor = this._xScale > 0 ? this._xScale : 1;
+        var widths = chars.map(function (ch) {
+            return ch === ' ' || ch === '\n'
+                ? height * 0.5 * widthFactor
+                : acdbEstimatePlainTextWidth(ch, height, widthFactor);
+        });
+        var widthsSum = widths.reduce(function (sum, width) { return sum + width; }, 0);
+        var convex = this._textPosition !== AcDbArcTextPosition.OnConcaveSide;
+        var outward = this._textDirection === AcDbArcTextDirection.OutwardFromCenter;
+        // Offset is the gap between the arc and the nearest edge of the text,
+        // not the baseline. Inward text has its baseline on the outer edge.
+        var arcEdge = Math.abs(this._radius) + (convex ? 1 : -1) * this._offsetFromArc;
+        var heightShift = convex === outward ? 0 : convex ? height : -height;
+        var radius = Math.max(1e-6, arcEdge + heightShift);
+        var sweep = this._endAngle - this._startAngle;
+        while (sweep <= 1e-9)
+            sweep += TWO_PI;
+        while (sweep > TWO_PI)
+            sweep -= TWO_PI;
+        var arcLength = sweep * radius;
+        var usable = Math.max(0, arcLength - this._leftOffset - this._rightOffset);
+        var gaps = Math.max(0, chars.length - 1);
+        var gap = this._characterSpacing;
+        if (this._alignment === AcDbArcTextAlignment.Fit && gaps > 0) {
+            gap = (usable - widthsSum) / gaps;
+        }
+        var natural = widthsSum + gap * gaps;
+        var distance = this._leftOffset;
+        if (this._alignment === AcDbArcTextAlignment.Right) {
+            distance = arcLength - this._rightOffset - natural;
+        }
+        else if (this._alignment === AcDbArcTextAlignment.Center ||
+            this._alignment === 0) {
+            distance = this._leftOffset + (usable - natural) / 2;
+        }
+        var extrusion = this.extrusionMatrix();
+        var glyphs = [];
+        for (var i = 0; i < chars.length; i++) {
+            var width = (_a = widths[i]) !== null && _a !== void 0 ? _a : 0;
+            var char = (_b = chars[i]) !== null && _b !== void 0 ? _b : '';
+            if (char === '\n')
+                continue;
+            var mid = distance + width / 2;
+            var angle = this._startAngle + mid / radius;
+            var local = new AcGePoint3d(this._center.x + radius * Math.cos(angle), this._center.y + radius * Math.sin(angle), this._center.z);
+            // Group 71 = 1 points glyph tops away from the center. Group 71 = 2
+            // points them toward the center, which keeps text upright along the
+            // bottom of a counter-clockwise arc.
+            var rotation = angle + Math.PI / 2;
+            if (this._textDirection === AcDbArcTextDirection.OutwardFromCenter) {
+                rotation += Math.PI;
+            }
+            glyphs.push({
+                text: char,
+                position: local.applyMatrix4(extrusion),
+                rotation: this.rotationInWcs(rotation, extrusion)
+            });
+            distance += width + gap;
+        }
+        return glyphs;
+    };
+    Object.defineProperty(AcDbArcAlignedText.prototype, "geometricExtents", {
+        get: function () {
+            var e_1, _a;
+            var box = new AcGeBox3d();
+            var glyphs = this.glyphPlacements();
+            if (glyphs.length === 0) {
+                box.expandByPoint(this._center);
+                return box;
+            }
+            var height = this._textSize > 0 ? this._textSize : 1;
+            try {
+                for (var glyphs_1 = __values(glyphs), glyphs_1_1 = glyphs_1.next(); !glyphs_1_1.done; glyphs_1_1 = glyphs_1.next()) {
+                    var glyph = glyphs_1_1.value;
+                    var width = acdbEstimatePlainTextWidth(glyph.text, height, this._xScale > 0 ? this._xScale : 1);
+                    var half = Math.max(width, height) / 2;
+                    box.expandByPoint(new AcGePoint3d(glyph.position.x - half, glyph.position.y - half, glyph.position.z));
+                    box.expandByPoint(new AcGePoint3d(glyph.position.x + half, glyph.position.y + half, glyph.position.z));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (glyphs_1_1 && !glyphs_1_1.done && (_a = glyphs_1.return)) _a.call(glyphs_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return box;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbArcAlignedText.prototype, "properties", {
+        get: function () {
+            var _this = this;
+            return {
+                type: this.type,
+                groups: [
+                    this.getGeneralProperties(),
+                    {
+                        groupName: 'text',
+                        properties: [
+                            {
+                                name: 'contents',
+                                type: 'string',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.textString; },
+                                    set: function (v) {
+                                        _this.textString = v;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'styleName',
+                                type: 'string',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.styleName; },
+                                    set: function (v) {
+                                        _this.styleName = v;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'textHeight',
+                                type: 'float',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.textSize; },
+                                    set: function (v) {
+                                        _this.textSize = v;
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                ]
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcDbArcAlignedText.prototype.subWorldDraw = function (renderer, delay) {
+        var e_2, _a;
+        var glyphs = this.glyphPlacements();
+        if (glyphs.length === 0)
+            return undefined;
+        var style = this.getTextStyle();
+        var height = this._textSize > 0 ? this._textSize : 1;
+        var entities = [];
+        try {
+            for (var glyphs_2 = __values(glyphs), glyphs_2_1 = glyphs_2.next(); !glyphs_2_1.done; glyphs_2_1 = glyphs_2.next()) {
+                var glyph = glyphs_2_1.value;
+                var text = this._isUnderlined ? "\\L".concat(glyph.text) : glyph.text;
+                var mtextData = {
+                    text: text,
+                    height: height,
+                    width: Infinity,
+                    widthFactor: this._xScale > 0 ? this._xScale : 1,
+                    position: glyph.position,
+                    rotation: glyph.rotation,
+                    drawingDirection: AcGiMTextFlowDirection.BOTTOM_TO_TOP,
+                    attachmentPoint: AcGiMTextAttachmentPoint.BaselineCenter
+                };
+                entities.push(renderer.mtext(mtextData, style, delay));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (glyphs_2_1 && !glyphs_2_1.done && (_a = glyphs_2.return)) _a.call(glyphs_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        if (entities.length === 1)
+            return entities[0];
+        return renderer.group(entities);
+    };
+    AcDbArcAlignedText.prototype.dxfOutFields = function (filer) {
+        _super.prototype.dxfOutFields.call(this, filer);
+        filer.writeSubclassMarker('AcDbArcAlignedText');
+        filer.writeString(1, this._textString);
+        filer.writeString(2, this._fontName);
+        filer.writeString(3, this._bigFontName);
+        filer.writeString(7, this._styleName);
+        filer.writePoint3d(10, this._center);
+        filer.writeDouble(40, this._radius);
+        filer.writeDouble(41, this._xScale);
+        filer.writeDouble(42, this._textSize);
+        filer.writeDouble(43, this._characterSpacing);
+        filer.writeDouble(44, this._offsetFromArc);
+        filer.writeDouble(45, this._rightOffset);
+        filer.writeDouble(46, this._leftOffset);
+        filer.writeAngle(50, this._startAngle);
+        filer.writeAngle(51, this._endAngle);
+        filer.writeInt16(70, this._isReverse ? 1 : 0);
+        filer.writeInt16(71, this._textDirection);
+        filer.writeInt16(72, this._alignment);
+        filer.writeInt16(73, this._textPosition);
+        filer.writeInt16(74, this._isBold ? 1 : 0);
+        filer.writeInt16(75, this._isItalic ? 1 : 0);
+        filer.writeInt16(76, this._isUnderlined ? 1 : 0);
+        filer.writeInt16(77, this._characterSet);
+        filer.writeInt16(78, this._pitchAndFamily);
+        filer.writeInt16(79, this._isShx ? 1 : 0);
+        filer.writeInt32(90, this.rawTextColor());
+        filer.writeVector3d(210, this._normal);
+        filer.writeInt16(280, this._wizardFlag);
+        if (this._arcId)
+            filer.writeHandle(330, this._arcId);
+        return this;
+    };
+    AcDbArcAlignedText.prototype.dxfInFields = function (filer) {
+        _super.prototype.dxfInFields.call(this, filer);
+        filer.atSubclassData('AcDbArcAlignedText');
+        var cx = this._center.x;
+        var cy = this._center.y;
+        var cz = this._center.z;
+        var nx = this._normal.x;
+        var ny = this._normal.y;
+        var nz = this._normal.z;
+        while (!filer.atEndOfObject && !filer.atEof && !filer.atExtendedData) {
+            var item = filer.readItem();
+            if (!item)
+                break;
+            var code = Number(item.code);
+            var n = Number(item.value);
+            var text = item.value == null ? '' : String(item.value);
+            switch (code) {
+                case 1:
+                    this._textString = text;
+                    break;
+                case 2:
+                    this._fontName = text;
+                    break;
+                case 3:
+                    this._bigFontName = text;
+                    break;
+                case 7:
+                    this._styleName = text;
+                    break;
+                case 10:
+                    cx = n;
+                    break;
+                case 20:
+                    cy = n;
+                    break;
+                case 30:
+                    cz = n;
+                    break;
+                case 40:
+                    this._radius = n;
+                    break;
+                case 41:
+                    this._xScale = n;
+                    break;
+                case 42:
+                    this._textSize = n;
+                    break;
+                case 43:
+                    this._characterSpacing = n;
+                    break;
+                case 44:
+                    this._offsetFromArc = n;
+                    break;
+                case 45:
+                    this._rightOffset = n;
+                    break;
+                case 46:
+                    this._leftOffset = n;
+                    break;
+                case 50:
+                    this._startAngle = n;
+                    break;
+                case 51:
+                    this._endAngle = n;
+                    break;
+                case 70:
+                    this._isReverse = n !== 0;
+                    break;
+                case 71:
+                    this._textDirection = n;
+                    break;
+                case 72:
+                    this._alignment = n;
+                    break;
+                case 73:
+                    this._textPosition = n;
+                    break;
+                case 74:
+                    this._isBold = n !== 0;
+                    break;
+                case 75:
+                    this._isItalic = n !== 0;
+                    break;
+                case 76:
+                    this._isUnderlined = n !== 0;
+                    break;
+                case 77:
+                    this._characterSet = n;
+                    break;
+                case 78:
+                    this._pitchAndFamily = n;
+                    break;
+                case 79:
+                    this._isShx = n !== 0;
+                    break;
+                case 90:
+                    this.applyRawTextColor(n);
+                    break;
+                case 210:
+                    nx = n;
+                    break;
+                case 220:
+                    ny = n;
+                    break;
+                case 230:
+                    nz = n;
+                    break;
+                case 280:
+                    this._wizardFlag = n;
+                    break;
+                case 330:
+                    this._arcId = text;
+                    break;
+                default:
+                    break;
+            }
+        }
+        this._center.set(cx, cy, cz);
+        this._normal.set(nx, ny, nz);
+        return this;
+    };
+    AcDbArcAlignedText.prototype.getTextStyle = function () {
+        var _a, _b, _c;
+        var table = (_b = (_a = this.database) === null || _a === void 0 ? void 0 : _a.tables) === null || _b === void 0 ? void 0 : _b.textStyleTable;
+        var record = (_c = table === null || table === void 0 ? void 0 : table.resolveAt(this._styleName)) !== null && _c !== void 0 ? _c : table === null || table === void 0 ? void 0 : table.resolveAt(DEFAULT_TEXT_STYLE);
+        var style = record
+            ? __assign({}, record.textStyle) : {
+            name: this._styleName || DEFAULT_TEXT_STYLE,
+            standardFlag: 0,
+            fixedTextHeight: 0,
+            widthFactor: this._xScale > 0 ? this._xScale : 1,
+            obliqueAngle: 0,
+            textGenerationFlag: 0,
+            lastHeight: this._textSize,
+            font: this._fontName || 'txt',
+            bigFont: this._bigFontName
+        };
+        if (this._fontName)
+            style.font = this._fontName;
+        if (this._bigFontName)
+            style.bigFont = this._bigFontName;
+        if (this._xScale > 0)
+            style.widthFactor = this._xScale;
+        return style;
+    };
+    AcDbArcAlignedText.prototype.isPlanarInWcs = function () {
+        return (Math.abs(this._normal.x) < 1e-10 &&
+            Math.abs(this._normal.y) < 1e-10 &&
+            this._normal.z > 0);
+    };
+    AcDbArcAlignedText.prototype.extrusionMatrix = function () {
+        if (this.isPlanarInWcs())
+            return new AcGeMatrix3d();
+        return new AcGeMatrix3d().setFromExtrusionDirection(this._normal);
+    };
+    AcDbArcAlignedText.prototype.rotationInWcs = function (rotation, extrusion) {
+        if (this.isPlanarInWcs())
+            return rotation;
+        var axis = new AcGeVector3d(Math.cos(rotation), Math.sin(rotation), 0);
+        axis.transformDirection(extrusion);
+        return Math.atan2(axis.y, axis.x);
+    };
+    AcDbArcAlignedText.typeName = 'ArcAlignedText';
+    return AcDbArcAlignedText;
+}(AcDbEntity));
+export { AcDbArcAlignedText };
+export function acdbParseArcAlignedNumber(value, fallback) {
+    if (fallback === void 0) { fallback = 0; }
+    return parseFinite(value, fallback);
+}
+//# sourceMappingURL=AcDbArcAlignedText.js.map