@mlightcad/data-model 1.11.3 → 1.12.0

package/lib/base/AcDbDxfFiler.js

@@ -1,3 +1,14 @@
+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 __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);
@@ -10,17 +21,55 @@ var __values = (this && this.__values) || function(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
 import { AcCmTransparencyMethod } from '@mlightcad/common';
+import { AcGePoint2d, AcGePoint3d, AcGeVector3d } from '@mlightcad/geometry-engine';
 import { AcDbDwgVersion } from '../database/AcDbDwgVersion';
+import { acdbDxfIsInt32Code, acdbDxfValueType } from './AcDbDxfGroupCodeTypes';
+import { acdbCreateDxfPairReader, acdbMakeAsciiDxfPairReader } from './AcDbDxfPairReader';
+import { ACDB_DXF_XDATA_BINARY_MAX_BYTES, ACDB_DXF_XDATA_STRING_MAX_BYTES, acdbChunkBinaryByMaxBytes, acdbChunkDxfMTextContents, acdbChunkUtf8ByMaxBytes } from './AcDbDxfStringChunks';
 /**
- * ASCII DXF writer that loosely mirrors the ObjectARX AcDbDxfFiler API.
+ * Lightweight status codes for DXF filing (ObjectARX-inspired).
+ */
+export var AcDbDxfFilerStatus;
+(function (AcDbDxfFilerStatus) {
+    AcDbDxfFilerStatus[AcDbDxfFilerStatus["Ok"] = 0] = "Ok";
+    AcDbDxfFilerStatus[AcDbDxfFilerStatus["EndOfFile"] = 1] = "EndOfFile";
+    AcDbDxfFilerStatus[AcDbDxfFilerStatus["EndOfObject"] = 2] = "EndOfObject";
+    AcDbDxfFilerStatus[AcDbDxfFilerStatus["InvalidDxfCode"] = 3] = "InvalidDxfCode";
+    AcDbDxfFilerStatus[AcDbDxfFilerStatus["BadDxfSequence"] = 4] = "BadDxfSequence";
+    AcDbDxfFilerStatus[AcDbDxfFilerStatus["NotThatKindOfClass"] = 5] = "NotThatKindOfClass";
+    AcDbDxfFilerStatus[AcDbDxfFilerStatus["WrongMode"] = 6] = "WrongMode";
+})(AcDbDxfFilerStatus || (AcDbDxfFilerStatus = {}));
+/** Magic prefix for AutoCAD Binary DXF files (22 bytes). */
+var BINARY_DXF_MAGIC = (function () {
+    var prefix = 'AutoCAD Binary DXF\r\n';
+    var bytes = new Uint8Array(22);
+    for (var i = 0; i < prefix.length; i++)
+        bytes[i] = prefix.charCodeAt(i);
+    bytes[20] = 0x1a;
+    bytes[21] = 0x00;
+    return bytes;
+})();
+/**
+ * DXF filer that mirrors the ObjectARX {@link AcDbDxfFiler} API.
  *
- * This implementation focuses on export scenarios in the web data model and
- * writes classic group-code based DXF text.
+ * - **Write mode** (default): accumulates classic group-code ASCII DXF text,
+ *   or binary DXF bytes when `outputFormat` is `'binary'`.
+ * - **Read mode**: pulls typed pairs from an {@link AcDbDxfPairReader} with
+ *   `readItem` / `pushBackItem` / `atEndOfObject` / `atSubclassData`.
  */
 var AcDbDxfFiler = /** @class */ (function () {
     function AcDbDxfFiler(options) {
         if (options === void 0) { options = {}; }
-        var _a;
+        var _a, _b;
+        this._binaryLength = 0;
+        /**
+         * Pushback stack for read mode (ObjectARX `pushBackItem`).
+         * LIFO: nested pushBacks are supported so a second push does not clobber
+         * the first.
+         */
+        this._pushed = [];
+        this._status = AcDbDxfFilerStatus.Ok;
+        this._errorMessage = '';
         this._database = options.database;
         this._precision = Math.max(0, Math.min(16, (_a = options.precision) !== null && _a !== void 0 ? _a : 16));
         this._version =
@@ -29,10 +78,39 @@ var AcDbDxfFiler = /** @class */ (function () {
                 : options.version != null
                     ? new AcDbDwgVersion(options.version)
                     : undefined;
+        this._outputFormat = (_b = options.outputFormat) !== null && _b !== void 0 ? _b : 'ascii';
         this._lines = [];
+        this._binaryChunks = [];
         this._handleMap = new Map();
         this._nextHandle = 1;
+        this._mode = options.reader ? 'read' : 'write';
+        this._reader = options.reader;
+        if (this._mode === 'write' && this._outputFormat === 'binary') {
+            this.appendBinary(BINARY_DXF_MAGIC);
+        }
     }
+    /** Create a read-mode filer from an existing pair reader. */
+    AcDbDxfFiler.forReading = function (reader, options) {
+        if (options === void 0) { options = {}; }
+        return new AcDbDxfFiler(__assign(__assign({}, options), { reader: reader }));
+    };
+    /** Create a read-mode filer from DXF bytes (ASCII or binary). */
+    AcDbDxfFiler.fromBuffer = function (data, options) {
+        if (options === void 0) { options = {}; }
+        return AcDbDxfFiler.forReading(acdbCreateDxfPairReader(data), options);
+    };
+    /** Create a read-mode filer from an already-decoded ASCII DXF string. */
+    AcDbDxfFiler.fromString = function (text, options) {
+        if (options === void 0) { options = {}; }
+        return AcDbDxfFiler.forReading(acdbMakeAsciiDxfPairReader(text), options);
+    };
+    Object.defineProperty(AcDbDxfFiler.prototype, "mode", {
+        get: function () {
+            return this._mode;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(AcDbDxfFiler.prototype, "database", {
         get: function () {
             return this._database;
@@ -68,14 +146,68 @@ var AcDbDxfFiler = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcDbDxfFiler.prototype, "filerStatus", {
+        get: function () {
+            return this._status;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDxfFiler.prototype, "errorMessage", {
+        get: function () {
+            return this._errorMessage;
+        },
+        enumerable: false,
+        configurable: true
+    });
     AcDbDxfFiler.prototype.setVersion = function (value) {
         this._version =
             value instanceof AcDbDwgVersion ? value : new AcDbDwgVersion(value);
         return this;
     };
+    AcDbDxfFiler.prototype.setError = function (status, message) {
+        if (message === void 0) { message = ''; }
+        this._status = status;
+        this._errorMessage = message;
+        return this;
+    };
+    AcDbDxfFiler.prototype.resetStatus = function () {
+        this._status = AcDbDxfFilerStatus.Ok;
+        this._errorMessage = '';
+        return this;
+    };
     AcDbDxfFiler.prototype.toString = function () {
+        this.assertWriteMode();
+        if (this._outputFormat === 'binary') {
+            throw new Error('Use toBinary() for binary DXF output');
+        }
         return this._lines.join('\n') + '\n';
     };
+    /** Finalize binary DXF bytes (includes magic prefix). */
+    AcDbDxfFiler.prototype.toBinary = function () {
+        var e_1, _a;
+        this.assertWriteMode();
+        if (this._outputFormat !== 'binary') {
+            throw new Error('Filer is not in binary output mode');
+        }
+        var out = new Uint8Array(this._binaryLength);
+        var offset = 0;
+        try {
+            for (var _b = __values(this._binaryChunks), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var chunk = _c.value;
+                out.set(chunk, offset);
+                offset += chunk.length;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return out;
+    };
     AcDbDxfFiler.prototype.registerHandle = function (key) {
         if (!this._handleMap.has(key)) {
             // If key is already a valid hex handle, preserve it
@@ -94,9 +226,265 @@ var AcDbDxfFiler = /** @class */ (function () {
             return undefined;
         return this.registerHandle(key);
     };
+    Object.defineProperty(AcDbDxfFiler.prototype, "atEof", {
+        // ---------------------------------------------------------------------------
+        // Read API (ObjectARX-inspired)
+        // ---------------------------------------------------------------------------
+        /** True if no more pairs are available. */
+        get: function () {
+            var _a;
+            if (this._mode !== 'read')
+                return false;
+            if (this._pushed.length > 0)
+                return false;
+            return ((_a = this._reader) === null || _a === void 0 ? void 0 : _a.peek()) === undefined;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Current read position in the underlying pair stream.
+     * Useful for byte-based parse progress while streaming a DXF.
+     */
+    AcDbDxfFiler.prototype.position = function () {
+        if (this._mode !== 'read' || !this._reader) {
+            return { byteOffset: 0 };
+        }
+        return this._reader.position();
+    };
+    Object.defineProperty(AcDbDxfFiler.prototype, "atEndOfObject", {
+        /**
+         * True if the next pair starts a new object (group code 0) or EOF.
+         * Does not consume the pair.
+         */
+        get: function () {
+            if (this._mode !== 'read')
+                return true;
+            var next = this.peekPair();
+            return next === undefined || next.code === 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDxfFiler.prototype, "atExtendedData", {
+        /** True if the next pair is XDATA start (1001) or similar extended data. */
+        get: function () {
+            if (this._mode !== 'read')
+                return false;
+            var next = this.peekPair();
+            if (!next)
+                return false;
+            return next.code === 1001 || next.code === 1000 || next.code === 1002;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Advance past subclass marker (100, name) if present.
+     * Returns true when positioned at the named subclass data.
+     */
+    AcDbDxfFiler.prototype.atSubclassData = function (name) {
+        if (this._mode !== 'read')
+            return false;
+        var next = this.peekPair();
+        if (!next || next.code !== 100)
+            return false;
+        if (typeof next.value !== 'string' || next.value !== name)
+            return false;
+        this.readPair();
+        return true;
+    };
+    /** Peek the next pair without consuming it. */
+    AcDbDxfFiler.prototype.peekItem = function () {
+        var pair = this.peekPair();
+        return pair ? this.pairToTypedValue(pair) : undefined;
+    };
+    /**
+     * Read one DXF item into a typed value (ObjectARX `readItem`).
+     * Returns undefined at EOF and sets {@link filerStatus} to EndOfFile.
+     */
+    AcDbDxfFiler.prototype.readItem = function () {
+        var pair = this.readPair();
+        if (!pair) {
+            this._status = AcDbDxfFilerStatus.EndOfFile;
+            return undefined;
+        }
+        this._status = AcDbDxfFilerStatus.Ok;
+        return this.pairToTypedValue(pair);
+    };
+    /**
+     * Push the last-read (or provided) pair back so the next read returns it.
+     * Multiple pushbacks form a LIFO stack (nested readers can push without
+     * overwriting a prior push).
+     */
+    AcDbDxfFiler.prototype.pushBackItem = function (item) {
+        if (item && 'type' in item) {
+            this._pushed.push(item);
+            return;
+        }
+        if (item) {
+            this._pushed.push(this.typedValueToPair(item));
+            return;
+        }
+        // No-arg form: re-push the last consumed pair.
+        if (this._lastRead) {
+            this._pushed.push(this._lastRead);
+        }
+    };
+    /** Skip pairs until the next object boundary (code 0) without consuming it. */
+    AcDbDxfFiler.prototype.skipToEndOfObject = function () {
+        while (!this.atEndOfObject && !this.atEof) {
+            this.readPair();
+        }
+    };
+    AcDbDxfFiler.prototype.readString = function (expectedCode) {
+        var pair = this.readPair();
+        if (!pair)
+            return undefined;
+        if (expectedCode != null && pair.code !== expectedCode) {
+            this.pushBackPair(pair);
+            this.setError(AcDbDxfFilerStatus.InvalidDxfCode, "Expected group code ".concat(expectedCode, ", got ").concat(pair.code));
+            return undefined;
+        }
+        if (pair.type === 'string' || pair.type === 'handle')
+            return pair.value;
+        return String(pair.value);
+    };
+    AcDbDxfFiler.prototype.readInt16 = function (expectedCode) {
+        return this.readNumber(expectedCode);
+    };
+    AcDbDxfFiler.prototype.readInt32 = function (expectedCode) {
+        return this.readNumber(expectedCode);
+    };
+    AcDbDxfFiler.prototype.readInt64 = function (expectedCode) {
+        var pair = this.readPair();
+        if (!pair)
+            return undefined;
+        if (expectedCode != null && pair.code !== expectedCode) {
+            this.pushBackPair(pair);
+            this.setError(AcDbDxfFilerStatus.InvalidDxfCode, "Expected group code ".concat(expectedCode, ", got ").concat(pair.code));
+            return undefined;
+        }
+        if (pair.type === 'long' || pair.type === 'int' || pair.type === 'double') {
+            return pair.value;
+        }
+        if (pair.type === 'bool')
+            return pair.value ? 1 : 0;
+        var n = Number(pair.value);
+        return Number.isFinite(n) ? n : 0;
+    };
+    AcDbDxfFiler.prototype.readDouble = function (expectedCode) {
+        return this.readNumber(expectedCode);
+    };
+    AcDbDxfFiler.prototype.readBoolean = function (expectedCode) {
+        var pair = this.readPair();
+        if (!pair)
+            return undefined;
+        if (expectedCode != null && pair.code !== expectedCode) {
+            this.pushBackPair(pair);
+            this.setError(AcDbDxfFilerStatus.InvalidDxfCode, "Expected group code ".concat(expectedCode, ", got ").concat(pair.code));
+            return undefined;
+        }
+        if (pair.type === 'bool')
+            return pair.value;
+        if (typeof pair.value === 'number')
+            return pair.value !== 0;
+        if (typeof pair.value === 'string') {
+            return pair.value !== '0' && pair.value !== '';
+        }
+        return Boolean(pair.value);
+    };
+    AcDbDxfFiler.prototype.readHandle = function (expectedCode) {
+        var pair = this.readPair();
+        if (!pair)
+            return undefined;
+        if (expectedCode != null && pair.code !== expectedCode) {
+            this.pushBackPair(pair);
+            this.setError(AcDbDxfFilerStatus.InvalidDxfCode, "Expected group code ".concat(expectedCode, ", got ").concat(pair.code));
+            return undefined;
+        }
+        if (pair.type === 'handle' || pair.type === 'string')
+            return pair.value;
+        return String(pair.value);
+    };
+    AcDbDxfFiler.prototype.readObjectId = function (expectedCode) {
+        return this.readHandle(expectedCode);
+    };
+    /**
+     * Read a 2D point starting at `code` (x), then `code+10` (y).
+     * Tolerates missing Y (defaults to 0) when the next code is not code+10.
+     */
+    AcDbDxfFiler.prototype.readPoint2d = function (code) {
+        var _a;
+        var x = this.readDouble(code);
+        if (x === undefined)
+            return undefined;
+        var next = this.peekPair();
+        var y = 0;
+        if (next && next.code === code + 10) {
+            y = (_a = this.readNumber()) !== null && _a !== void 0 ? _a : 0;
+        }
+        return new AcGePoint2d(x, y);
+    };
+    /**
+     * Read a 3D point starting at `code` (x), then `code+10` / `code+20`.
+     * Missing Y/Z default to 0 when those group codes are absent.
+     */
+    AcDbDxfFiler.prototype.readPoint3d = function (code) {
+        var _a, _b;
+        var x = this.readDouble(code);
+        if (x === undefined)
+            return undefined;
+        var y = 0;
+        var z = 0;
+        var n1 = this.peekPair();
+        if (n1 && n1.code === code + 10) {
+            y = (_a = this.readNumber()) !== null && _a !== void 0 ? _a : 0;
+        }
+        var n2 = this.peekPair();
+        if (n2 && n2.code === code + 20) {
+            z = (_b = this.readNumber()) !== null && _b !== void 0 ? _b : 0;
+        }
+        return new AcGePoint3d(x, y, z);
+    };
+    AcDbDxfFiler.prototype.readVector3d = function (code) {
+        var p = this.readPoint3d(code);
+        return p ? new AcGeVector3d(p.x, p.y, p.z) : undefined;
+    };
+    /**
+     * Apply color group codes (62 ACI / 420 true color) onto `color` when the
+     * current pair matches. Returns true if a color code was consumed.
+     */
+    AcDbDxfFiler.prototype.readCmColorInto = function (color, aciCode, trueColorCode) {
+        if (aciCode === void 0) { aciCode = 62; }
+        if (trueColorCode === void 0) { trueColorCode = 420; }
+        var next = this.peekPair();
+        if (!next)
+            return false;
+        if (next.code === aciCode) {
+            var v = this.readNumber();
+            if (v != null)
+                color.colorIndex = v;
+            return true;
+        }
+        if (next.code === trueColorCode) {
+            var v = this.readNumber();
+            if (v != null)
+                color.setRGBValue(v);
+            return true;
+        }
+        return false;
+    };
+    // ---------------------------------------------------------------------------
+    // Write API
+    // ---------------------------------------------------------------------------
     AcDbDxfFiler.prototype.writeGroup = function (code, value) {
+        this.assertWriteMode();
         if (value == null)
             return this;
+        if (this._outputFormat === 'binary') {
+            return this.writeBinaryGroup(code, value);
+        }
         this._lines.push(String(Math.trunc(code)));
         var text = this.formatValue(value);
         // Never emit an empty value line — it breaks DXF pairing (e.g. "70\n\n4") and
@@ -107,7 +495,21 @@ var AcDbDxfFiler = /** @class */ (function () {
     AcDbDxfFiler.prototype.writeStart = function (value) {
         return this.writeString(0, value);
     };
+    Object.defineProperty(AcDbDxfFiler.prototype, "capabilities", {
+        /**
+         * DXF dialect capabilities for the target write version.
+         * When version is unset (ad-hoc writers / unit tests), treat as latest.
+         */
+        get: function () {
+            var _a;
+            return ((_a = this._version) !== null && _a !== void 0 ? _a : AcDbDwgVersion.latest).capabilities;
+        },
+        enumerable: false,
+        configurable: true
+    });
     AcDbDxfFiler.prototype.writeSubclassMarker = function (value) {
+        if (!this.capabilities.supportsSubclassMarkers)
+            return this;
         return this.writeString(100, value);
     };
     AcDbDxfFiler.prototype.writeString = function (code, value) {
@@ -115,6 +517,27 @@ var AcDbDxfFiler = /** @class */ (function () {
             return this;
         return this.writeGroup(code, value);
     };
+    /**
+     * Write MTEXT (or embedded-MTEXT) contents using AutoCAD's group 3 / group 1
+     * 250-character chunking rules.
+     */
+    AcDbDxfFiler.prototype.writeMTextContents = function (text) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(acdbChunkDxfMTextContents(text !== null && text !== void 0 ? text : '')), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var chunk = _c.value;
+                this.writeString(chunk.code, chunk.value);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return this;
+    };
     AcDbDxfFiler.prototype.writeInt8 = function (code, value) {
         return value == null ? this : this.writeGroup(code, Math.trunc(value));
     };
@@ -150,12 +573,20 @@ var AcDbDxfFiler = /** @class */ (function () {
         return this.writeDouble(code, (radians * 180) / Math.PI);
     };
     AcDbDxfFiler.prototype.writeHandle = function (code, key) {
+        if (!this.capabilities.supportsHandles)
+            return this;
         var handle = this.resolveHandle(key);
         return handle ? this.writeString(code, handle) : this;
     };
     AcDbDxfFiler.prototype.writeObjectId = function (code, objectId) {
         return this.writeHandle(code, objectId);
     };
+    /** Lineweight (group 370). Omitted for DXF targets before AutoCAD 2000. */
+    AcDbDxfFiler.prototype.writeLineWeight = function (code, value) {
+        if (value == null || !this.capabilities.supportsLineWeight)
+            return this;
+        return this.writeInt16(code, value);
+    };
     AcDbDxfFiler.prototype.writePoint2d = function (code, point) {
         if (!point)
             return this;
@@ -192,34 +623,89 @@ var AcDbDxfFiler = /** @class */ (function () {
         }
         var rgb = color.RGB;
         if (rgb != null && color.colorIndex == null) {
-            this.writeInt32(trueColorCode, rgb);
+            if (this.capabilities.supportsTrueColor) {
+                this.writeInt32(trueColorCode, rgb);
+            }
+            else {
+                // Pre-2004 DXF has no 420 — fall back to ACI white.
+                this.writeInt16(aciCode, 7);
+            }
         }
         return this;
     };
     AcDbDxfFiler.prototype.writeTransparency = function (transparency, code) {
         if (code === void 0) { code = 440; }
         if (!transparency ||
-            transparency.method === AcCmTransparencyMethod.ErrorValue) {
+            transparency.method === AcCmTransparencyMethod.ErrorValue ||
+            !this.capabilities.supportsTransparency) {
             return this;
         }
         return this.writeInt32(code, transparency.serialize());
     };
     AcDbDxfFiler.prototype.writeResultBuffer = function (data) {
-        var e_1, _a;
+        var e_3, _a, e_4, _b, e_5, _c;
         if (!data)
             return this;
         try {
             for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
                 var item = data_1_1.value;
+                var code = Number(item.code);
+                // XData ASCII strings are limited to 255 bytes per group 1000.
+                if (code === 1000 && typeof item.value === 'string') {
+                    try {
+                        for (var _d = (e_4 = void 0, __values(acdbChunkUtf8ByMaxBytes(item.value, ACDB_DXF_XDATA_STRING_MAX_BYTES))), _e = _d.next(); !_e.done; _e = _d.next()) {
+                            var chunk = _e.value;
+                            this.writeGroup(1000, chunk);
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                    continue;
+                }
+                // XData binary chunks are limited to 127 bytes per group 1004.
+                if (code === 1004) {
+                    var bytes = item.value instanceof Uint8Array
+                        ? item.value
+                        : typeof item.value === 'string'
+                            ? acdbHexToBytes(item.value)
+                            : undefined;
+                    if (bytes) {
+                        try {
+                            for (var _f = (e_5 = void 0, __values(acdbChunkBinaryByMaxBytes(bytes, ACDB_DXF_XDATA_BINARY_MAX_BYTES))), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                var chunk = _g.value;
+                                // ASCII DXF stores 1004 as hex; binary DXF stores raw bytes.
+                                if (this._outputFormat === 'binary') {
+                                    this.writeGroup(1004, chunk);
+                                }
+                                else {
+                                    this.writeGroup(1004, acdbBytesToHex(chunk));
+                                }
+                            }
+                        }
+                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                        finally {
+                            try {
+                                if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+                            }
+                            finally { if (e_5) throw e_5.error; }
+                        }
+                        continue;
+                    }
+                }
                 this.writeGroup(item.code, item.value);
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
                 if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
             }
-            finally { if (e_1) throw e_1.error; }
+            finally { if (e_3) throw e_3.error; }
         }
         return this;
     };
@@ -241,6 +727,181 @@ var AcDbDxfFiler = /** @class */ (function () {
         this.writeStart('ENDTAB');
         return this;
     };
+    // ---------------------------------------------------------------------------
+    // Internals
+    // ---------------------------------------------------------------------------
+    AcDbDxfFiler.prototype.assertWriteMode = function () {
+        if (this._mode !== 'write') {
+            throw new Error('AcDbDxfFiler is in read mode');
+        }
+    };
+    AcDbDxfFiler.prototype.appendBinary = function (bytes) {
+        this._binaryChunks.push(bytes);
+        this._binaryLength += bytes.length;
+    };
+    AcDbDxfFiler.prototype.writeBinaryCode = function (code) {
+        var truncated = Math.trunc(code) & 0xffff;
+        // AC1009 binary DXF uses 1-byte codes with 0xFF escape for codes > 255.
+        var legacyR12 = !this.capabilities.supportsSubclassMarkers;
+        if (legacyR12) {
+            if (truncated <= 0xff) {
+                this.appendBinary(Uint8Array.of(truncated));
+            }
+            else {
+                this.appendBinary(Uint8Array.of(0xff, truncated & 0xff, (truncated >> 8) & 0xff));
+            }
+            return;
+        }
+        var buf = new Uint8Array(2);
+        new DataView(buf.buffer).setUint16(0, truncated, true);
+        this.appendBinary(buf);
+    };
+    AcDbDxfFiler.prototype.writeBinaryGroup = function (code, value) {
+        var type = acdbDxfValueType(Math.trunc(code));
+        this.writeBinaryCode(Math.trunc(code));
+        switch (type) {
+            case 'string':
+            case 'handle': {
+                var text = typeof value === 'string'
+                    ? this.sanitizeStringForDxfLine(value)
+                    : this.formatValue(value);
+                var encoded = new TextEncoder().encode(text === '' ? '0' : text);
+                var withNul = new Uint8Array(encoded.length + 1);
+                withNul.set(encoded);
+                withNul[encoded.length] = 0;
+                this.appendBinary(withNul);
+                break;
+            }
+            case 'int': {
+                var n = Math.trunc(Number(value)) || 0;
+                if (acdbDxfIsInt32Code(Math.trunc(code))) {
+                    var buf = new Uint8Array(4);
+                    new DataView(buf.buffer).setInt32(0, n, true);
+                    this.appendBinary(buf);
+                }
+                else {
+                    var buf = new Uint8Array(2);
+                    new DataView(buf.buffer).setInt16(0, n, true);
+                    this.appendBinary(buf);
+                }
+                break;
+            }
+            case 'long': {
+                var buf = new Uint8Array(8);
+                var view = new DataView(buf.buffer);
+                if (typeof value === 'bigint') {
+                    view.setBigInt64(0, value, true);
+                }
+                else {
+                    view.setBigInt64(0, BigInt(Math.trunc(Number(value)) || 0), true);
+                }
+                this.appendBinary(buf);
+                break;
+            }
+            case 'double': {
+                var buf = new Uint8Array(8);
+                var n = Number(value);
+                new DataView(buf.buffer).setFloat64(0, Number.isFinite(n) ? n : 0, true);
+                this.appendBinary(buf);
+                break;
+            }
+            case 'bool': {
+                var b = typeof value === 'boolean'
+                    ? value
+                    : Number(value) !== 0 && value !== '' && value != null;
+                this.appendBinary(Uint8Array.of(b ? 1 : 0));
+                break;
+            }
+            case 'binary': {
+                var bytes = value instanceof Uint8Array
+                    ? value
+                    : new Uint8Array(0);
+                var length_1 = Math.min(255, bytes.length);
+                var chunk = new Uint8Array(1 + length_1);
+                chunk[0] = length_1;
+                chunk.set(bytes.subarray(0, length_1), 1);
+                this.appendBinary(chunk);
+                break;
+            }
+            default: {
+                var text = this.formatValue(value);
+                var encoded = new TextEncoder().encode(text === '' ? '0' : text);
+                var withNul = new Uint8Array(encoded.length + 1);
+                withNul.set(encoded);
+                withNul[encoded.length] = 0;
+                this.appendBinary(withNul);
+                break;
+            }
+        }
+        return this;
+    };
+    AcDbDxfFiler.prototype.assertReadMode = function () {
+        if (this._mode !== 'read' || !this._reader) {
+            throw new Error('AcDbDxfFiler is not in read mode');
+        }
+    };
+    AcDbDxfFiler.prototype.peekPair = function () {
+        this.assertReadMode();
+        if (this._pushed.length > 0) {
+            return this._pushed[this._pushed.length - 1];
+        }
+        return this._reader.peek();
+    };
+    AcDbDxfFiler.prototype.readPair = function () {
+        this.assertReadMode();
+        if (this._pushed.length > 0) {
+            var p_1 = this._pushed.pop();
+            this._lastRead = p_1;
+            return p_1;
+        }
+        var p = this._reader.next();
+        this._lastRead = p;
+        return p;
+    };
+    AcDbDxfFiler.prototype.pushBackPair = function (pair) {
+        this._pushed.push(pair);
+    };
+    AcDbDxfFiler.prototype.readNumber = function (expectedCode) {
+        var pair = this.readPair();
+        if (!pair)
+            return undefined;
+        if (expectedCode != null && pair.code !== expectedCode) {
+            this.pushBackPair(pair);
+            this.setError(AcDbDxfFilerStatus.InvalidDxfCode, "Expected group code ".concat(expectedCode, ", got ").concat(pair.code));
+            return undefined;
+        }
+        if (pair.type === 'double' ||
+            pair.type === 'int' ||
+            pair.type === 'long') {
+            var v = pair.value;
+            return typeof v === 'bigint' ? Number(v) : v;
+        }
+        if (pair.type === 'bool')
+            return pair.value ? 1 : 0;
+        var n = Number(pair.value);
+        return Number.isFinite(n) ? n : 0;
+    };
+    AcDbDxfFiler.prototype.pairToTypedValue = function (pair) {
+        return { code: pair.code, value: pair.value };
+    };
+    AcDbDxfFiler.prototype.typedValueToPair = function (item) {
+        var code = Number(item.code);
+        var value = item.value;
+        if (typeof value === 'boolean')
+            return { code: code, type: 'bool', value: value };
+        if (typeof value === 'number') {
+            // Prefer double for floats; int for integers — callers rarely push back
+            // typed values, so double is a safe default for numbers.
+            if (Number.isInteger(value))
+                return { code: code, type: 'int', value: value };
+            return { code: code, type: 'double', value: value };
+        }
+        if (typeof value === 'bigint')
+            return { code: code, type: 'long', value: value };
+        if (value instanceof Uint8Array)
+            return { code: code, type: 'binary', value: value };
+        return { code: code, type: 'string', value: String(value !== null && value !== void 0 ? value : '') };
+    };
     AcDbDxfFiler.prototype.formatValue = function (value) {
         if (typeof value === 'string') {
             // ASCII DXF: one value must occupy a single line. Raw CR/LF inside a value
@@ -261,6 +922,9 @@ var AcDbDxfFiler = /** @class */ (function () {
                 return '0';
             return trimmed;
         }
+        if (value instanceof Uint8Array) {
+            return acdbBytesToHex(value);
+        }
         return String(value);
     };
     /** Removes characters that must not appear on a single DXF value line. */
@@ -273,4 +937,21 @@ var AcDbDxfFiler = /** @class */ (function () {
     return AcDbDxfFiler;
 }());
 export { AcDbDxfFiler };
+function acdbBytesToHex(bytes) {
+    var _a;
+    var out = '';
+    for (var i = 0; i < bytes.length; i++) {
+        out += ((_a = bytes[i]) !== null && _a !== void 0 ? _a : 0).toString(16).padStart(2, '0').toUpperCase();
+    }
+    return out;
+}
+function acdbHexToBytes(hex) {
+    var trimmed = hex.replace(/\s+/g, '');
+    var byteLength = trimmed.length >>> 1;
+    var bytes = new Uint8Array(byteLength);
+    for (var j = 0; j < byteLength; j++) {
+        bytes[j] = Number.parseInt(trimmed.slice(j * 2, j * 2 + 2), 16) || 0;
+    }
+    return bytes;
+}
 //# sourceMappingURL=AcDbDxfFiler.js.map