@mlightcad/data-model 1.15.2 → 1.15.4

package/lib/base/AcDbDxfPairReader.d.ts

@@ -32,19 +32,10 @@ export declare function acdbPeekDxfHeaderInfo(buffer: ArrayBuffer): AcDbDxfHeade
  */
 export declare function acdbMakeAsciiDxfPairReader(text: string): AcDbDxfPairReader;
 /**
- * Bytes decoded per `TextDecoder` call in {@link acdbMakeUtf8AsciiDxfPairReader}.
- *
- * Sized as a compromise: large enough that a multi-MB DXF costs hundreds of
- * decode calls rather than one per line, small enough that windows still holding
- * a retained value slice do not pin much memory.
- */
-/**
- * ASCII pair reader that decodes UTF-8 bytes one line-aligned window at a time,
- * instead of allocating a full-file decoded string (peak memory ≈ input bytes
- * plus one window).
- *
- * Non-UTF-8 code pages still go through {@link acdbMakeAsciiDxfPairReader}
- * after a full `TextDecoder` pass.
+ * ASCII pair reader that decodes UTF-8 bytes one line at a time, instead of
+ * allocating a full-file decoded string (peak memory ≈ input bytes plus one
+ * line). Legacy code pages use the same span path via
+ * {@link acdbCreateDxfPairReader}.
  */
 export declare function acdbMakeUtf8AsciiDxfPairReader(bytes: Uint8Array): AcDbDxfPairReader;
 /**
@@ -58,14 +49,16 @@ export declare function acdbMakeBinaryDxfPairReader(data: Uint8Array, options?:
 }): AcDbDxfPairReader;
 export interface AcDbCreateDxfPairReaderOptions {
     /**
-     * Override text encoding for ASCII DXF.
+     * Override text encoding for ASCII and binary DXF.
      *
-     * When omitted, the encoding is chosen automatically: bytes that validate
-     * as UTF-8 decode as UTF-8; otherwise a declared pre-2007 `$DWGCODEPAGE`
-     * is honored (see {@link acdbCreateDxfPairReader}). When provided, it wins
-     * over detection — use it to force e.g. `'cp949'` for Korean drawings whose
-     * header lies. Common non-WHATWG aliases such as `'cp949'` are normalized
-     * to a supported `TextDecoder` label (`'euc-kr'`).
+     * When omitted, the encoding is chosen automatically: ASCII bytes that
+     * validate as UTF-8 decode as UTF-8; otherwise a declared pre-2007
+     * `$DWGCODEPAGE` is honored. Binary DXF peeks the same header fields and
+     * applies a pre-2007 code page to null-terminated strings (see
+     * {@link acdbCreateDxfPairReader}). When provided, it wins over detection
+     * — use it to force e.g. `'cp949'` for Korean drawings whose header lies.
+     * Common non-WHATWG aliases such as `'cp949'` are normalized to a
+     * supported `TextDecoder` label (`'euc-kr'`).
      */
     encoding?: string;
     /** Force R12 1-byte group codes for binary DXF. */
@@ -77,16 +70,23 @@ export interface AcDbCreateDxfPairReaderOptions {
  * ASCII path encoding strategy (hybrid of byte-trust and header sniffing):
  *
  * 1. An explicit `options.encoding` always wins — the caller asserts the
- *    encoding, no sniffing contradicts it.
+ *    encoding, no sniffing contradicts it. Non-UTF-8 overrides decode
+ *    line-by-line (never a single full-file string).
  * 2. Otherwise the bytes are strictly validated as UTF-8. Valid UTF-8
  *    (including pure ASCII) decodes correctly regardless of any stale
  *    `$DWGCODEPAGE`, so the header is never consulted — modern files skip
  *    the header pre-scan entirely and stream straight from bytes.
  * 3. Invalid UTF-8 means the file is not a spec-conformant modern DXF. The
  *    HEADER is then peeked for `$ACADVER`/`$DWGCODEPAGE`: pre-2007 drawings
- *    with a declared code page decode through it (matching AutoCAD), while
- *    R2007+ or headerless files fall back to UTF-8 (replacement chars mark
- *    the broken bytes).
+ *    with a declared code page decode through it span-by-span (matching
+ *    AutoCAD, without materializing one giant string), while R2007+ or
+ *    headerless files fall back to UTF-8 (replacement chars mark the
+ *    broken bytes).
+ *
+ * Binary path: when `options.encoding` is omitted, the HEADER is peeked for
+ * a pre-2007 `$DWGCODEPAGE` and that code page is used for null-terminated
+ * string values (same AutoCAD rule as ASCII). R2007+ / missing header keep
+ * UTF-8.
  */
 export declare function acdbCreateDxfPairReader(data: ArrayBuffer | Uint8Array, options?: AcDbCreateDxfPairReaderOptions): AcDbDxfPairReader;
 //# sourceMappingURL=AcDbDxfPairReader.d.ts.map

package/lib/base/AcDbDxfPairReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcDbDxfPairReader.d.ts","sourceRoot":"","sources":["../../src/base/AcDbDxfPairReader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAU3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAwBhD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAA;IACjC,IAAI,IAAI,WAAW,GAAG,SAAS,CAAA;IAC/B,IAAI,IAAI,WAAW,GAAG,SAAS,CAAA;IAC/B,QAAQ,IAAI;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAA;CAClD;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;IAC9B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAMzD;AAkjBD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,iBAAiB,CA0C5E;AAoDD;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CA+D1E;AAOD;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,UAAU,GAChB,iBAAiB,CAEnB;AASD;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACvD,iBAAiB,CAoKnB;AAED,MAAM,WAAW,8BAA8B;IAC7C;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,mDAAmD;IACnD,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAqDD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,UAAU,EAC9B,OAAO,GAAE,8BAAmC,GAC3C,iBAAiB,CA4EnB"}
+{"version":3,"file":"AcDbDxfPairReader.d.ts","sourceRoot":"","sources":["../../src/base/AcDbDxfPairReader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAU3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAwBhD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAA;IACjC,IAAI,IAAI,WAAW,GAAG,SAAS,CAAA;IAC/B,IAAI,IAAI,WAAW,GAAG,SAAS,CAAA;IAC/B,QAAQ,IAAI;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAA;CAClD;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;IAC9B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAMzD;AA+rBD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,iBAAiB,CAuC5E;AAoDD;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CA+D1E;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,UAAU,GAChB,iBAAiB,CAEnB;AASD;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACvD,iBAAiB,CAqKnB;AAED,MAAM,WAAW,8BAA8B;IAC7C;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,mDAAmD;IACnD,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAqDD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,UAAU,EAC9B,OAAO,GAAE,8BAAmC,GAC3C,iBAAiB,CA0EnB"}

package/lib/base/AcDbDxfPairReader.js

@@ -72,16 +72,21 @@ function acdbDecodeAsciiSpan(bytes, start, end) {
     return text;
 }
 /**
- * Decodes a UTF-8 byte span, taking the ASCII fast path when possible.
+ * Decodes a text byte span, taking the ASCII fast path when possible.
  *
  * `nonAscii` must be true exactly when the span holds a byte `>= 0x80`. It is
  * produced by the line scanner, so this function never re-scans the span.
+ *
+ * For legacy DXF code pages (windows-1252, euc-kr, gbk, shift-jis, …) the
+ * trail-byte ranges never include `0x0A`/`0x0D`, so each line is a complete
+ * character sequence and may be decoded independently — same invariant the
+ * UTF-8 reader relies on.
  */
-function acdbDecodeUtf8Span(bytes, start, end, nonAscii) {
+function acdbDecodeTextSpan(bytes, start, end, nonAscii, decoder) {
     if (!nonAscii) {
         return acdbDecodeAsciiSpan(bytes, start, end);
     }
-    return UTF8_DECODER.decode(bytes.subarray(start, end));
+    return decoder.decode(bytes.subarray(start, end));
 }
 /**
  * Parses an integer group code straight from the bytes of a code line,
@@ -90,9 +95,9 @@ function acdbDecodeUtf8Span(bytes, start, end, nonAscii) {
  * Returns NaN for blank or malformed code lines. DXF group code lines are
  * pure ASCII; the rare non-ASCII line falls back to `Number` + `isFinite`.
  */
-function acdbReadDxfCodeFromBytes(bytes, start, end, nonAscii) {
+function acdbReadDxfCodeFromBytes(bytes, start, end, nonAscii, decoder) {
     if (nonAscii) {
-        var n = Number(acdbDecodeUtf8Span(bytes, start, end, true).trim());
+        var n = Number(acdbDecodeTextSpan(bytes, start, end, true, decoder).trim());
         return Number.isFinite(n) ? n : NaN;
     }
     var i = start;
@@ -364,13 +369,13 @@ function acdbDecodeHexBinaryText(text, start, end) {
 /**
  * Decodes a code-310 hex line from bytes, trimming ASCII whitespace.
  */
-function acdbDecodeHexBinarySpan(bytes, start, end, nonAscii) {
+function acdbDecodeHexBinarySpan(bytes, start, end, nonAscii, decoder) {
     while (start < end && acdbIsAsciiWhitespace(bytes[start]))
         start++;
     while (end > start && acdbIsAsciiWhitespace(bytes[end - 1]))
         end--;
     if (nonAscii) {
-        var text = acdbDecodeUtf8Span(bytes, start, end, true);
+        var text = acdbDecodeTextSpan(bytes, start, end, true, decoder);
         return acdbDecodeHexBinaryText(text, 0, text.length);
     }
     var byteLength = (end - start) >>> 1;
@@ -388,7 +393,7 @@ function acdbDecodeHexBinarySpan(bytes, start, end, nonAscii) {
  * nonAscii is the flag produced by the line scanner for this exact span; it
  * is forwarded to every decode helper so no helper has to re-scan the bytes.
  */
-function parseAsciiValueSpan(code, bytes, start, end, nonAscii) {
+function parseAsciiValueSpan(code, bytes, start, end, nonAscii, decoder) {
     var type = acdbDxfValueType(code);
     if (type === 'comment')
         return null;
@@ -397,12 +402,12 @@ function parseAsciiValueSpan(code, bytes, start, end, nonAscii) {
             return {
                 code: code,
                 type: type,
-                value: acdbDecodeUtf8Span(bytes, start, end, nonAscii)
+                value: acdbDecodeTextSpan(bytes, start, end, nonAscii, decoder)
             };
         case 'int': {
             var fast = acdbParseIntSpan(bytes, start, end);
             var n = fast === undefined
-                ? parseInt(acdbDecodeUtf8Span(bytes, start, end, nonAscii), 10)
+                ? parseInt(acdbDecodeTextSpan(bytes, start, end, nonAscii, decoder), 10)
                 : fast;
             return { code: code, type: type, value: Number.isFinite(n) ? n : 0 };
         }
@@ -410,7 +415,7 @@ function parseAsciiValueSpan(code, bytes, start, end, nonAscii) {
             var fast = acdbParseLongSpan(bytes, start, end);
             if (fast !== undefined)
                 return { code: code, type: type, value: fast };
-            var raw = acdbDecodeUtf8Span(bytes, start, end, nonAscii);
+            var raw = acdbDecodeTextSpan(bytes, start, end, nonAscii, decoder);
             var n = Number(raw);
             if (Number.isSafeInteger(n))
                 return { code: code, type: type, value: n };
@@ -424,7 +429,7 @@ function parseAsciiValueSpan(code, bytes, start, end, nonAscii) {
         case 'double': {
             var fast = acdbParseDoubleSpan(bytes, start, end);
             var n = fast === undefined
-                ? Number(acdbDecodeUtf8Span(bytes, start, end, nonAscii))
+                ? Number(acdbDecodeTextSpan(bytes, start, end, nonAscii, decoder))
                 : fast;
             return { code: code, type: type, value: Number.isFinite(n) ? n : 0 };
         }
@@ -432,11 +437,11 @@ function parseAsciiValueSpan(code, bytes, start, end, nonAscii) {
             var fast = acdbDxfRawBoolIsTrue(bytes, start, end, nonAscii);
             if (fast !== undefined)
                 return { code: code, type: type, value: fast };
-            var trimmed = acdbDecodeUtf8Span(bytes, start, end, nonAscii).trim();
+            var trimmed = acdbDecodeTextSpan(bytes, start, end, nonAscii, decoder).trim();
             return { code: code, type: type, value: trimmed !== '' && trimmed !== '0' };
         }
         case 'handle': {
-            var value = acdbDecodeUtf8Span(bytes, start, end, nonAscii);
+            var value = acdbDecodeTextSpan(bytes, start, end, nonAscii, decoder);
             if (value.length === 0)
                 return { code: code, type: type, value: value };
             var first = value.charCodeAt(0);
@@ -450,19 +455,32 @@ function parseAsciiValueSpan(code, bytes, start, end, nonAscii) {
             return {
                 code: code,
                 type: type,
-                value: acdbDecodeHexBinarySpan(bytes, start, end, nonAscii)
+                value: acdbDecodeHexBinarySpan(bytes, start, end, nonAscii, decoder)
             };
         default:
             return null;
     }
 }
+function isUtf8Encoding(encoding) {
+    var e = encoding.toLowerCase().replace(/_/g, '-');
+    return e === 'utf-8' || e === 'utf8' || e === 'unicode-1-1-utf-8';
+}
 /**
- * ASCII/UTF-8 pair reader over raw bytes.
+ * ASCII pair reader over raw bytes, decoding non-ASCII spans with `encoding`.
  *
- * Line breaks are single bytes and UTF-8 continuation bytes never equal
- * 0x0A/0x0D, so non-ASCII text values never straddle line boundaries.
+ * Line breaks are single bytes. For UTF-8, continuation bytes never equal
+ * `0x0A`/`0x0D`. The same holds for the legacy DXF code pages we support
+ * (windows-125x, euc-kr/cp949, gbk, shift-jis, big5, …): their trail-byte
+ * ranges exclude CR/LF, so non-ASCII text values never straddle line
+ * boundaries and each line may be decoded independently.
+ *
+ * @param encoding - WHATWG / `TextDecoder` label. Defaults to UTF-8.
  */
-function acdbMakeUtf8DxfPairReader(bytes) {
+function acdbMakeByteAsciiDxfPairReader(bytes, encoding) {
+    if (encoding === void 0) { encoding = 'utf-8'; }
+    var decoder = isUtf8Encoding(encoding)
+        ? UTF8_DECODER
+        : new TextDecoder(encoding);
     var pos = bytes.length >= 3 &&
         bytes[0] === 0xef &&
         bytes[1] === 0xbb &&
@@ -506,7 +524,7 @@ function acdbMakeUtf8DxfPairReader(bytes) {
             var codeSpan = readLineSpan();
             if (codeSpan === undefined)
                 return undefined;
-            var code = acdbReadDxfCodeFromBytes(bytes, codeSpan.start, codeSpan.end, codeSpan.nonAscii);
+            var code = acdbReadDxfCodeFromBytes(bytes, codeSpan.start, codeSpan.end, codeSpan.nonAscii, decoder);
             if (Number.isNaN(code))
                 continue;
             if (code === 999) {
@@ -517,7 +535,7 @@ function acdbMakeUtf8DxfPairReader(bytes) {
             var valueSpan = readLineSpan();
             if (valueSpan === undefined)
                 return undefined;
-            var pair = parseAsciiValueSpan(code, bytes, valueSpan.start, valueSpan.end, valueSpan.nonAscii);
+            var pair = parseAsciiValueSpan(code, bytes, valueSpan.start, valueSpan.end, valueSpan.nonAscii, decoder);
             if (pair)
                 return pair;
         }
@@ -545,6 +563,95 @@ function acdbMakeUtf8DxfPairReader(bytes) {
         }
     };
 }
+function acdbMakeUtf8DxfPairReader(bytes) {
+    return acdbMakeByteAsciiDxfPairReader(bytes, 'utf-8');
+}
+/**
+ * Resolve a `$DWGCODEPAGE` header value to a `TextDecoder` label.
+ * Unknown names yield `null` so callers keep their UTF-8 fallback.
+ */
+function acdbResolveDwgCodePageEncoding(value) {
+    var _a;
+    if (!value)
+        return null;
+    var codePage = AcDbCodePage[value];
+    if (codePage === undefined)
+        return null;
+    return (_a = acdbDwgCodePageToEncoding(codePage)) !== null && _a !== void 0 ? _a : null;
+}
+/**
+ * Peek `$ACADVER` / `$DWGCODEPAGE` from a binary DXF HEADER section.
+ *
+ * Header keywords and code-page names are ASCII, so the temporary reader
+ * uses UTF-8 regardless of the drawing's text encoding.
+ */
+function acdbPeekBinaryDxfHeaderInfo(data, legacyR12) {
+    var reader = acdbMakeBinaryDxfPairReader(data, {
+        encoding: 'utf-8',
+        legacyR12: legacyR12
+    });
+    var version = null;
+    var encoding = null;
+    var inHeader = false;
+    var pendingVar = null;
+    for (var pair = reader.next(); pair; pair = reader.next()) {
+        if (pair.code === 0 && pair.type === 'string') {
+            var name_1 = pair.value;
+            if (name_1 === 'SECTION') {
+                var section = reader.next();
+                if ((section === null || section === void 0 ? void 0 : section.code) === 2 &&
+                    section.type === 'string' &&
+                    section.value === 'HEADER') {
+                    inHeader = true;
+                }
+                pendingVar = null;
+                continue;
+            }
+            if (name_1 === 'ENDSEC' && inHeader) {
+                return { version: version, encoding: encoding };
+            }
+            pendingVar = null;
+            continue;
+        }
+        if (!inHeader)
+            continue;
+        if (pair.code === 9 && pair.type === 'string') {
+            pendingVar = pair.value;
+            continue;
+        }
+        if (pendingVar === '$ACADVER' && pair.code === 1 && pair.type === 'string') {
+            try {
+                version = new AcDbDwgVersion(pair.value);
+            }
+            catch (_a) {
+                // Unrecognized spelling: leave version null.
+            }
+        }
+        else if (pendingVar === '$DWGCODEPAGE' &&
+            pair.code === 3 &&
+            pair.type === 'string') {
+            encoding = acdbResolveDwgCodePageEncoding(pair.value);
+        }
+        if (pendingVar !== null) {
+            pendingVar = null;
+            if (version && encoding)
+                return { version: version, encoding: encoding };
+        }
+    }
+    return { version: version, encoding: encoding };
+}
+/**
+ * Prefer a pre-2007 `$DWGCODEPAGE` when the header declares both a legacy
+ * version and a known code page; otherwise return null (caller keeps UTF-8).
+ */
+function acdbLegacyEncodingFromHeader(info) {
+    if (info.version &&
+        !info.version.capabilities.supportsUtf8CodePage &&
+        info.encoding) {
+        return info.encoding;
+    }
+    return null;
+}
 /**
  * Peek `$ACADVER` / `$DWGCODEPAGE` from the HEADER section without decoding
  * the whole file. Uses 64 KiB UTF-8 chunks (same strategy as AcDbDxfParser).
@@ -580,10 +687,8 @@ export function acdbPeekDxfHeaderInfo(buffer) {
             }
             else if (inHeader && line === '$DWGCODEPAGE') {
                 var value = (_d = lines[i + 2]) === null || _d === void 0 ? void 0 : _d.trim();
-                if (value) {
-                    var codePage = AcDbCodePage[value];
-                    encoding = acdbDwgCodePageToEncoding(codePage);
-                }
+                if (value)
+                    encoding = acdbResolveDwgCodePageEncoding(value);
             }
             if (version && encoding)
                 return { version: version, encoding: encoding };
@@ -714,24 +819,11 @@ export function acdbMakeAsciiDxfPairReader(text) {
         }
     };
 }
-function isUtf8Encoding(encoding) {
-    var e = encoding.toLowerCase().replace(/_/g, '-');
-    return e === 'utf-8' || e === 'utf8' || e === 'unicode-1-1-utf-8';
-}
 /**
- * Bytes decoded per `TextDecoder` call in {@link acdbMakeUtf8AsciiDxfPairReader}.
- *
- * Sized as a compromise: large enough that a multi-MB DXF costs hundreds of
- * decode calls rather than one per line, small enough that windows still holding
- * a retained value slice do not pin much memory.
- */
-/**
- * ASCII pair reader that decodes UTF-8 bytes one line-aligned window at a time,
- * instead of allocating a full-file decoded string (peak memory ≈ input bytes
- * plus one window).
- *
- * Non-UTF-8 code pages still go through {@link acdbMakeAsciiDxfPairReader}
- * after a full `TextDecoder` pass.
+ * ASCII pair reader that decodes UTF-8 bytes one line at a time, instead of
+ * allocating a full-file decoded string (peak memory ≈ input bytes plus one
+ * line). Legacy code pages use the same span path via
+ * {@link acdbCreateDxfPairReader}.
  */
 export function acdbMakeUtf8AsciiDxfPairReader(bytes) {
     return acdbMakeUtf8DxfPairReader(bytes);
@@ -753,6 +845,7 @@ export function acdbMakeBinaryDxfPairReader(data, options) {
     if (options === void 0) { options = {}; }
     var encoding = (_a = options.encoding) !== null && _a !== void 0 ? _a : 'utf-8';
     var legacyR12 = (_b = options.legacyR12) !== null && _b !== void 0 ? _b : false;
+    var decoder = new TextDecoder(encoding);
     var PREFIX = 22;
     var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
     var offset = data.length >= PREFIX ? PREFIX : data.length;
@@ -791,7 +884,7 @@ export function acdbMakeBinaryDxfPairReader(data, options) {
             return undefined;
         var bytes = data.subarray(start, offset);
         offset += 1;
-        return new TextDecoder(encoding).decode(bytes);
+        return decoder.decode(bytes);
     }
     function readInt16() {
         if (offset + 2 > data.length)
@@ -998,18 +1091,26 @@ function acdbIsValidUtf8(bytes) {
  * ASCII path encoding strategy (hybrid of byte-trust and header sniffing):
  *
  * 1. An explicit `options.encoding` always wins — the caller asserts the
- *    encoding, no sniffing contradicts it.
+ *    encoding, no sniffing contradicts it. Non-UTF-8 overrides decode
+ *    line-by-line (never a single full-file string).
  * 2. Otherwise the bytes are strictly validated as UTF-8. Valid UTF-8
  *    (including pure ASCII) decodes correctly regardless of any stale
  *    `$DWGCODEPAGE`, so the header is never consulted — modern files skip
  *    the header pre-scan entirely and stream straight from bytes.
  * 3. Invalid UTF-8 means the file is not a spec-conformant modern DXF. The
  *    HEADER is then peeked for `$ACADVER`/`$DWGCODEPAGE`: pre-2007 drawings
- *    with a declared code page decode through it (matching AutoCAD), while
- *    R2007+ or headerless files fall back to UTF-8 (replacement chars mark
- *    the broken bytes).
+ *    with a declared code page decode through it span-by-span (matching
+ *    AutoCAD, without materializing one giant string), while R2007+ or
+ *    headerless files fall back to UTF-8 (replacement chars mark the
+ *    broken bytes).
+ *
+ * Binary path: when `options.encoding` is omitted, the HEADER is peeked for
+ * a pre-2007 `$DWGCODEPAGE` and that code page is used for null-terminated
+ * string values (same AutoCAD rule as ASCII). R2007+ / missing header keep
+ * UTF-8.
  */
 export function acdbCreateDxfPairReader(data, options) {
+    var _a;
     if (options === void 0) { options = {}; }
     var bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
     var overrideEncoding = options.encoding
@@ -1018,35 +1119,38 @@ export function acdbCreateDxfPairReader(data, options) {
     if (acdbIsBinaryDxf(bytes)) {
         var encoding = overrideEncoding;
         var legacyR12 = options.legacyR12;
-        if (encoding == null || legacyR12 == null) {
-            encoding = encoding !== null && encoding !== void 0 ? encoding : 'utf-8';
-            if (legacyR12 == null) {
-                // After the 22-byte magic: R12 uses 1-byte codes (`0,'S'`), modern
-                // uses 2-byte LE codes (`0,0,'S'`) for the first SECTION marker.
-                var PREFIX = 22;
-                var b0 = bytes[PREFIX];
-                var b1 = bytes[PREFIX + 1];
-                var b2 = bytes[PREFIX + 2];
-                if (b0 === 0 && b1 === 0x53 /* 'S' */) {
-                    legacyR12 = true;
-                }
-                else if (b0 === 0 && b1 === 0 && b2 === 0x53 /* 'S' */) {
-                    legacyR12 = false;
-                }
-                else {
-                    legacyR12 = false;
-                }
+        if (legacyR12 == null) {
+            // After the 22-byte magic: R12 uses 1-byte codes (`0,'S'`), modern
+            // uses 2-byte LE codes (`0,0,'S'`) for the first SECTION marker.
+            var PREFIX = 22;
+            var b0 = bytes[PREFIX];
+            var b1 = bytes[PREFIX + 1];
+            var b2 = bytes[PREFIX + 2];
+            if (b0 === 0 && b1 === 0x53 /* 'S' */) {
+                legacyR12 = true;
+            }
+            else if (b0 === 0 && b1 === 0 && b2 === 0x53 /* 'S' */) {
+                legacyR12 = false;
             }
+            else {
+                legacyR12 = false;
+            }
+        }
+        if (encoding == null) {
+            try {
+                encoding =
+                    (_a = acdbLegacyEncodingFromHeader(acdbPeekBinaryDxfHeaderInfo(bytes, legacyR12))) !== null && _a !== void 0 ? _a : undefined;
+            }
+            catch (_b) {
+                // Unrecognized $ACADVER: stay on UTF-8.
+            }
+            encoding = encoding !== null && encoding !== void 0 ? encoding : 'utf-8';
         }
         return acdbMakeBinaryDxfPairReader(bytes, { encoding: encoding, legacyR12: legacyR12 });
     }
     // 1. Explicit override wins: the caller asserts the encoding.
     if (overrideEncoding) {
-        if (isUtf8Encoding(overrideEncoding)) {
-            return acdbMakeUtf8DxfPairReader(bytes);
-        }
-        var text = new TextDecoder(overrideEncoding).decode(bytes);
-        return acdbMakeAsciiDxfPairReader(text);
+        return acdbMakeByteAsciiDxfPairReader(bytes, overrideEncoding);
     }
     // 2. Trust the bytes first: valid UTF-8 (including pure ASCII) is decoded
     //    correctly no matter what a stale $DWGCODEPAGE claims, so modern files
@@ -1055,27 +1159,23 @@ export function acdbCreateDxfPairReader(data, options) {
         return acdbMakeUtf8DxfPairReader(bytes);
     }
     // 3. Invalid UTF-8: fall back to the pre-2007 $DWGCODEPAGE when one is
-    //    declared (genuine legacy ANSI content). R2007+ or headerless files
-    //    stay on UTF-8, where replacement characters mark the broken bytes.
+    //    declared (genuine legacy ANSI content). Decode span-by-span so large
+    //    drawings never hit the V8 max-string-length ceiling. R2007+ or
+    //    headerless files stay on UTF-8, where replacement characters mark
+    //    the broken bytes.
     var legacyEncoding = null;
     try {
         var buffer = bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
             ? bytes.buffer
             : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-        var info = acdbPeekDxfHeaderInfo(buffer);
-        if (info.version &&
-            !info.version.capabilities.supportsUtf8CodePage &&
-            info.encoding) {
-            legacyEncoding = info.encoding;
-        }
+        legacyEncoding = acdbLegacyEncodingFromHeader(acdbPeekDxfHeaderInfo(buffer));
     }
-    catch (_a) {
+    catch (_c) {
         // Unrecognized $ACADVER spelling: treat as version-less and stay UTF-8
         // instead of failing the whole read.
     }
     if (legacyEncoding) {
-        var text = new TextDecoder(legacyEncoding).decode(bytes);
-        return acdbMakeAsciiDxfPairReader(text);
+        return acdbMakeByteAsciiDxfPairReader(bytes, legacyEncoding);
     }
     return acdbMakeUtf8DxfPairReader(bytes);
 }