@mlightcad/data-model 1.14.11 → 1.14.13

package/lib/base/AcDbDxfPairReader.js

@@ -11,6 +11,7 @@ var BINARY_DXF_MAGIC = (function () {
     bytes[21] = 0x00;
     return bytes;
 })();
+var UTF8_DECODER = new TextDecoder('utf-8');
 var HEX_NIBBLE = (function () {
     var t = new Int8Array(128);
     for (var i = 0; i < 10; i++)
@@ -30,6 +31,520 @@ export function acdbIsBinaryDxf(data) {
     }
     return true;
 }
+/** ASCII whitespace used around DXF numeric fields (String.trim's ASCII set). */
+function acdbIsAsciiWhitespace(c) {
+    return c === 0x20 || (c >= 0x09 && c <= 0x0d);
+}
+/** True for every character `String.prototype.trim` strips. */
+function acdbIsTrimWhitespace(c) {
+    return (acdbIsAsciiWhitespace(c) ||
+        c === 0xa0 ||
+        c === 0x1680 ||
+        c === 0x2028 ||
+        c === 0x2029 ||
+        c === 0x202f ||
+        c === 0x205f ||
+        c === 0x3000 ||
+        c === 0xfeff ||
+        (c >= 0x2000 && c <= 0x200a));
+}
+/**
+ * Decodes a pure-ASCII byte span without constructing a `TextDecoder` call or
+ * an intermediate `Uint8Array` copy. DXF keywords, handles and numeric text
+ * are overwhelmingly ASCII.
+ */
+function acdbDecodeAsciiSpan(bytes, start, end) {
+    var length = end - start;
+    if (length <= 0)
+        return '';
+    if (length <= 16) {
+        var text_1 = '';
+        for (var i = start; i < end; i++)
+            text_1 += String.fromCharCode(bytes[i]);
+        return text_1;
+    }
+    var CHUNK = 4096;
+    var text = '';
+    for (var pos = start; pos < end; pos += CHUNK) {
+        var chunkEnd = Math.min(pos + CHUNK, end);
+        text += String.fromCharCode.apply(null, bytes.subarray(pos, chunkEnd));
+    }
+    return text;
+}
+/**
+ * Decodes a UTF-8 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.
+ */
+function acdbDecodeUtf8Span(bytes, start, end, nonAscii) {
+    if (!nonAscii) {
+        return acdbDecodeAsciiSpan(bytes, start, end);
+    }
+    return UTF8_DECODER.decode(bytes.subarray(start, end));
+}
+/**
+ * Parses an integer group code straight from the bytes of a code line,
+ * without allocating the line string or a trimmed copy.
+ *
+ * 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) {
+    if (nonAscii) {
+        var n = Number(acdbDecodeUtf8Span(bytes, start, end, true).trim());
+        return Number.isFinite(n) ? n : NaN;
+    }
+    var i = start;
+    while (i < end && acdbIsAsciiWhitespace(bytes[i]))
+        i++;
+    if (i >= end)
+        return NaN;
+    var sign = 1;
+    var c0 = bytes[i];
+    if (c0 === 0x2d) {
+        sign = -1;
+        i++;
+    }
+    else if (c0 === 0x2b) {
+        i++;
+    }
+    var value = 0;
+    var digits = 0;
+    while (i < end) {
+        var c = bytes[i];
+        if (c >= 0x30 && c <= 0x39) {
+            value = value * 10 + (c - 0x30);
+            digits++;
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    if (digits === 0)
+        return NaN;
+    while (i < end) {
+        if (!acdbIsAsciiWhitespace(bytes[i]))
+            return NaN;
+        i++;
+    }
+    return sign * value;
+}
+/**
+ * Largest integer mantissa for which one more accumulation step is still exact
+ * as a double: below (2^53 - 9) / 10 we always stay representable.
+ */
+var MAX_EXACT_DOUBLE_MANTISSA = (Number.MAX_SAFE_INTEGER - 9) / 10;
+/**
+ * Fast path for double value lines: parses `[+-]?digits[.digits][eE[+-]digits]`
+ * straight from the byte span, without slicing the line or calling `Number()`.
+ * Returns undefined outside its exact domain (caller falls back).
+ */
+function acdbParseDoubleSpan(bytes, start, end) {
+    var i = start;
+    while (i < end && acdbIsAsciiWhitespace(bytes[i]))
+        i++;
+    if (i >= end)
+        return 0;
+    var sign = 1;
+    var c0 = bytes[i];
+    if (c0 === 0x2d) {
+        sign = -1;
+        i++;
+    }
+    else if (c0 === 0x2b) {
+        i++;
+    }
+    var mantissa = 0;
+    var exp10 = 0;
+    var anyDigit = false;
+    var tooLong = false;
+    while (i < end) {
+        var c = bytes[i];
+        if (c < 0x30 || c > 0x39)
+            break;
+        anyDigit = true;
+        i++;
+        if (mantissa === 0 && c === 0x30)
+            continue;
+        if (mantissa > MAX_EXACT_DOUBLE_MANTISSA) {
+            tooLong = true;
+            continue;
+        }
+        mantissa = mantissa * 10 + (c - 0x30);
+    }
+    if (i < end && bytes[i] === 0x2e) {
+        i++;
+        while (i < end) {
+            var c = bytes[i];
+            if (c < 0x30 || c > 0x39)
+                break;
+            anyDigit = true;
+            i++;
+            if (mantissa === 0 && c === 0x30) {
+                exp10--;
+                continue;
+            }
+            if (mantissa > MAX_EXACT_DOUBLE_MANTISSA) {
+                tooLong = true;
+                continue;
+            }
+            mantissa = mantissa * 10 + (c - 0x30);
+            exp10--;
+        }
+    }
+    if (i < end && (bytes[i] === 0x65 || bytes[i] === 0x45)) {
+        i++;
+        var expSign = 1;
+        var sc = bytes[i];
+        if (sc === 0x2d) {
+            expSign = -1;
+            i++;
+        }
+        else if (sc === 0x2b) {
+            i++;
+        }
+        var expVal = 0;
+        var expDigits = 0;
+        while (i < end) {
+            var c = bytes[i];
+            if (c < 0x30 || c > 0x39)
+                break;
+            i++;
+            expDigits++;
+            if (expVal <= 10000)
+                expVal = expVal * 10 + (c - 0x30);
+        }
+        if (expDigits === 0)
+            return undefined;
+        exp10 += expSign * expVal;
+    }
+    while (i < end) {
+        if (!acdbIsAsciiWhitespace(bytes[i]))
+            return undefined;
+        i++;
+    }
+    if (!anyDigit)
+        return 0;
+    if (tooLong)
+        return undefined;
+    if (mantissa === 0)
+        return sign * mantissa;
+    if (exp10 > 22 || exp10 < -22)
+        return undefined;
+    var scale = 1;
+    var k = exp10 < 0 ? -exp10 : exp10;
+    for (var n = 0; n < k; n++)
+        scale *= 10;
+    return sign * (exp10 < 0 ? mantissa / scale : mantissa * scale);
+}
+/**
+ * Fast path for int value lines with parseInt semantics: skips leading
+ * whitespace, takes the longest digit run, ignores the rest. Returns
+ * undefined when non-ASCII whitespace may precede the digits or for digit
+ * runs longer than 15 (so the caller falls back).
+ */
+function acdbParseIntSpan(bytes, start, end) {
+    var i = start;
+    for (;;) {
+        if (i >= end)
+            break;
+        var c = bytes[i];
+        if (c >= 0x80)
+            return undefined;
+        if (!acdbIsAsciiWhitespace(c))
+            break;
+        i++;
+    }
+    var sign = 1;
+    var c0 = bytes[i];
+    if (c0 === 0x2d) {
+        sign = -1;
+        i++;
+    }
+    else if (c0 === 0x2b) {
+        i++;
+    }
+    if (i < end && bytes[i] >= 0x80)
+        return undefined;
+    var value = 0;
+    var digits = 0;
+    var anyDigit = false;
+    while (i < end) {
+        var c = bytes[i];
+        if (c < 0x30 || c > 0x39)
+            break;
+        i++;
+        anyDigit = true;
+        if (value === 0 && c === 0x30)
+            continue;
+        if (digits >= 15)
+            return undefined;
+        value = value * 10 + (c - 0x30);
+        digits++;
+    }
+    return anyDigit ? sign * value : 0;
+}
+/**
+ * Fast path for long value lines with Number semantics (whole line must be
+ * numeric, unlike parseInt). Returns the integer when it has at most 15
+ * significant digits; otherwise undefined (caller falls back to Number/BigInt).
+ */
+function acdbParseLongSpan(bytes, start, end) {
+    var i = start;
+    while (i < end && acdbIsAsciiWhitespace(bytes[i]))
+        i++;
+    var sign = 1;
+    var c0 = bytes[i];
+    if (c0 === 0x2d) {
+        sign = -1;
+        i++;
+    }
+    else if (c0 === 0x2b) {
+        i++;
+    }
+    var value = 0;
+    var digits = 0;
+    var anyDigit = false;
+    while (i < end) {
+        var c = bytes[i];
+        if (c < 0x30 || c > 0x39)
+            break;
+        i++;
+        anyDigit = true;
+        if (value === 0 && c === 0x30)
+            continue;
+        if (digits >= 15)
+            return undefined;
+        value = value * 10 + (c - 0x30);
+        digits++;
+    }
+    while (i < end) {
+        if (!acdbIsAsciiWhitespace(bytes[i]))
+            return undefined;
+        i++;
+    }
+    return anyDigit ? sign * value : 0;
+}
+/**
+ * Equivalent to `trimmed !== '' && trimmed !== '0'` without allocating.
+ * nonAscii comes from the line scanner; non-ASCII spans bail out so the caller
+ * can use the exact String.prototype.trim semantics.
+ */
+function acdbDxfRawBoolIsTrue(bytes, start, end, nonAscii) {
+    if (nonAscii)
+        return undefined;
+    while (start < end && acdbIsAsciiWhitespace(bytes[start]))
+        start++;
+    while (end > start && acdbIsAsciiWhitespace(bytes[end - 1]))
+        end--;
+    if (start >= end)
+        return false;
+    return !(end - start === 1 && bytes[start] === 0x30);
+}
+/**
+ * Decodes a hex pair value straight from a character span. Used only as a rare
+ * fallback when a binary value line contains non-ASCII bytes.
+ */
+function acdbDecodeHexBinaryText(text, start, end) {
+    while (start < end && acdbIsTrimWhitespace(text.charCodeAt(start)))
+        start++;
+    while (end > start && acdbIsTrimWhitespace(text.charCodeAt(end - 1)))
+        end--;
+    var byteLength = (end - start) >>> 1;
+    var bytes = new Uint8Array(byteLength);
+    for (var j = 0; j < byteLength; j++) {
+        var hi = HEX_NIBBLE[text.charCodeAt(start + j * 2) & 0x7f];
+        var lo = HEX_NIBBLE[text.charCodeAt(start + j * 2 + 1) & 0x7f];
+        bytes[j] = (hi << 4) | lo;
+    }
+    return bytes;
+}
+/**
+ * Decodes a code-310 hex line from bytes, trimming ASCII whitespace.
+ */
+function acdbDecodeHexBinarySpan(bytes, start, end, nonAscii) {
+    while (start < end && acdbIsAsciiWhitespace(bytes[start]))
+        start++;
+    while (end > start && acdbIsAsciiWhitespace(bytes[end - 1]))
+        end--;
+    if (nonAscii) {
+        var text = acdbDecodeUtf8Span(bytes, start, end, true);
+        return acdbDecodeHexBinaryText(text, 0, text.length);
+    }
+    var byteLength = (end - start) >>> 1;
+    var out = new Uint8Array(byteLength);
+    for (var j = 0; j < byteLength; j++) {
+        var hi = HEX_NIBBLE[bytes[start + j * 2] & 0x7f];
+        var lo = HEX_NIBBLE[bytes[start + j * 2 + 1] & 0x7f];
+        out[j] = (hi << 4) | lo;
+    }
+    return out;
+}
+/**
+ * Parses one ASCII value line.
+ *
+ * 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) {
+    var type = acdbDxfValueType(code);
+    if (type === 'comment')
+        return null;
+    switch (type) {
+        case 'string':
+            return {
+                code: code,
+                type: type,
+                value: acdbDecodeUtf8Span(bytes, start, end, nonAscii)
+            };
+        case 'int': {
+            var fast = acdbParseIntSpan(bytes, start, end);
+            var n = fast === undefined
+                ? parseInt(acdbDecodeUtf8Span(bytes, start, end, nonAscii), 10)
+                : fast;
+            return { code: code, type: type, value: Number.isFinite(n) ? n : 0 };
+        }
+        case 'long': {
+            var fast = acdbParseLongSpan(bytes, start, end);
+            if (fast !== undefined)
+                return { code: code, type: type, value: fast };
+            var raw = acdbDecodeUtf8Span(bytes, start, end, nonAscii);
+            var n = Number(raw);
+            if (Number.isSafeInteger(n))
+                return { code: code, type: type, value: n };
+            try {
+                return { code: code, type: type, value: BigInt(raw.trim()) };
+            }
+            catch (_a) {
+                return { code: code, type: type, value: 0 };
+            }
+        }
+        case 'double': {
+            var fast = acdbParseDoubleSpan(bytes, start, end);
+            var n = fast === undefined
+                ? Number(acdbDecodeUtf8Span(bytes, start, end, nonAscii))
+                : fast;
+            return { code: code, type: type, value: Number.isFinite(n) ? n : 0 };
+        }
+        case 'bool': {
+            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();
+            return { code: code, type: type, value: trimmed !== '' && trimmed !== '0' };
+        }
+        case 'handle': {
+            var value = acdbDecodeUtf8Span(bytes, start, end, nonAscii);
+            if (value.length === 0)
+                return { code: code, type: type, value: value };
+            var first = value.charCodeAt(0);
+            var last = value.charCodeAt(value.length - 1);
+            if (!acdbIsTrimWhitespace(first) && !acdbIsTrimWhitespace(last)) {
+                return { code: code, type: type, value: value };
+            }
+            return { code: code, type: type, value: value.trim() };
+        }
+        case 'binary':
+            return {
+                code: code,
+                type: type,
+                value: acdbDecodeHexBinarySpan(bytes, start, end, nonAscii)
+            };
+        default:
+            return null;
+    }
+}
+/**
+ * ASCII/UTF-8 pair reader over raw bytes.
+ *
+ * Line breaks are single bytes and UTF-8 continuation bytes never equal
+ * 0x0A/0x0D, so non-ASCII text values never straddle line boundaries.
+ */
+function acdbMakeUtf8DxfPairReader(bytes) {
+    var pos = bytes.length >= 3 &&
+        bytes[0] === 0xef &&
+        bytes[1] === 0xbb &&
+        bytes[2] === 0xbf
+        ? 3
+        : 0;
+    var lineNumber = 1;
+    var lookahead;
+    var lookaheadValid = false;
+    /**
+     * Advances past one line and returns its content byte range.
+     *
+     * The scan also ORs every content byte, so nonAscii ("this line holds a
+     * byte >= 0x80") comes for free and the value/code parsers never have to walk
+     * the line a second time.
+     */
+    function readLineSpan() {
+        if (pos >= bytes.length)
+            return undefined;
+        var start = pos;
+        var contentEnd = pos;
+        var flags = 0;
+        while (contentEnd < bytes.length) {
+            var c = bytes[contentEnd];
+            if (c === 0x0a || c === 0x0d)
+                break;
+            flags |= c;
+            contentEnd++;
+        }
+        var end = contentEnd;
+        if (end < bytes.length && bytes[end] === 0x0d)
+            end++;
+        if (end < bytes.length && bytes[end] === 0x0a)
+            end++;
+        pos = end;
+        lineNumber++;
+        return { start: start, end: contentEnd, nonAscii: flags >= 0x80 };
+    }
+    function readRaw() {
+        for (;;) {
+            var codeSpan = readLineSpan();
+            if (codeSpan === undefined)
+                return undefined;
+            var code = acdbReadDxfCodeFromBytes(bytes, codeSpan.start, codeSpan.end, codeSpan.nonAscii);
+            if (Number.isNaN(code))
+                continue;
+            if (code === 999) {
+                if (readLineSpan() === undefined)
+                    return undefined;
+                continue;
+            }
+            var valueSpan = readLineSpan();
+            if (valueSpan === undefined)
+                return undefined;
+            var pair = parseAsciiValueSpan(code, bytes, valueSpan.start, valueSpan.end, valueSpan.nonAscii);
+            if (pair)
+                return pair;
+        }
+    }
+    return {
+        kind: 'ascii',
+        next: function () {
+            if (lookaheadValid) {
+                var pair = lookahead;
+                lookahead = undefined;
+                lookaheadValid = false;
+                return pair;
+            }
+            return readRaw();
+        },
+        peek: function () {
+            if (!lookaheadValid) {
+                lookahead = readRaw();
+                lookaheadValid = true;
+            }
+            return lookahead;
+        },
+        position: function () {
+            return { line: lineNumber, byteOffset: pos };
+        }
+    };
+}
 /**
  * Peek `$ACADVER` / `$DWGCODEPAGE` from the HEADER section without decoding
  * the whole file. Uses 64 KiB UTF-8 chunks (same strategy as AcDbDxfParser).
@@ -210,7 +725,6 @@ function isUtf8Encoding(encoding) {
  * decode calls rather than one per line, small enough that windows still holding
  * a retained value slice do not pin much memory.
  */
-var UTF8_DECODE_WINDOW_BYTES = 64 * 1024;
 /**
  * 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
@@ -220,112 +734,7 @@ var UTF8_DECODE_WINDOW_BYTES = 64 * 1024;
  * after a full `TextDecoder` pass.
  */
 export function acdbMakeUtf8AsciiDxfPairReader(bytes) {
-    // Skip UTF-8 BOM when present.
-    var start = bytes.length >= 3 &&
-        bytes[0] === 0xef &&
-        bytes[1] === 0xbb &&
-        bytes[2] === 0xbf
-        ? 3
-        : 0;
-    var lineNumber = 1;
-    var lookahead;
-    var lookaheadValid = false;
-    var decoder = new TextDecoder('utf-8');
-    // Decoded window covering bytes [windowStart, windowEnd), scanned by a
-    // character cursor. Windows end just past a line break, and a break byte can
-    // never appear inside a multi-byte UTF-8 sequence, so each window decodes
-    // standalone and no line ever straddles two windows.
-    var windowStart = start;
-    var windowEnd = start;
-    var text = '';
-    var textPos = 0;
-    /** Decodes the next window. Returns `false` once the input is exhausted. */
-    function advanceWindow() {
-        if (windowEnd >= bytes.length)
-            return false;
-        windowStart = windowEnd;
-        var end = Math.min(windowStart + UTF8_DECODE_WINDOW_BYTES, bytes.length);
-        while (end < bytes.length && bytes[end] !== 10 && bytes[end] !== 13)
-            end++;
-        if (end < bytes.length && bytes[end] === 13)
-            end++;
-        if (end < bytes.length && bytes[end] === 10)
-            end++;
-        windowEnd = end;
-        text = decoder.decode(bytes.subarray(windowStart, windowEnd));
-        textPos = 0;
-        return true;
-    }
-    function readLine() {
-        while (textPos >= text.length) {
-            if (!advanceWindow())
-                return undefined;
-        }
-        var end = textPos;
-        while (end < text.length) {
-            var c = text.charCodeAt(end);
-            if (c === 10 || c === 13)
-                break;
-            end++;
-        }
-        var line = text.slice(textPos, end);
-        if (end < text.length && text.charCodeAt(end) === 13)
-            end++;
-        if (end < text.length && text.charCodeAt(end) === 10)
-            end++;
-        textPos = end;
-        lineNumber++;
-        return line;
-    }
-    function readRaw() {
-        for (;;) {
-            var codeRaw = readLine();
-            if (codeRaw === undefined)
-                return undefined;
-            var codeTrimmed = codeRaw.trim();
-            if (codeTrimmed === '')
-                continue;
-            var valueRaw = readLine();
-            if (valueRaw === undefined)
-                return undefined;
-            var code = Number(codeTrimmed);
-            if (!Number.isFinite(code))
-                continue;
-            if (code === 999)
-                continue;
-            var pair = parseAsciiValue(code, valueRaw);
-            if (pair)
-                return pair;
-        }
-    }
-    return {
-        kind: 'ascii',
-        next: function () {
-            if (lookaheadValid) {
-                var p = lookahead;
-                lookahead = undefined;
-                lookaheadValid = false;
-                return p;
-            }
-            return readRaw();
-        },
-        peek: function () {
-            if (!lookaheadValid) {
-                lookahead = readRaw();
-                lookaheadValid = true;
-            }
-            return lookahead;
-        },
-        position: function () {
-            // Interpolated inside the current window: callers use this only to report
-            // parse progress, so window-level precision is enough.
-            var span = windowEnd - windowStart;
-            var byteOffset = span > 0 && text.length > 0
-                ? windowStart + Math.round((textPos / text.length) * span)
-                : windowEnd;
-            return { line: lineNumber, byteOffset: byteOffset };
-        }
-    };
+    return acdbMakeUtf8DxfPairReader(bytes);
 }
 function safeBigIntToNumber(v) {
     var max = BigInt(Number.MAX_SAFE_INTEGER);
@@ -520,12 +929,85 @@ export function acdbMakeBinaryDxfPairReader(data, options) {
         }
     };
 }
+/**
+ * Strict UTF-8 validation (rejects stray continuation bytes, overlong forms,
+ * surrogate halves and anything beyond U+10FFFF). Used to tell genuine legacy
+ * ANSI bytes apart from UTF-8 content hiding behind a stale pre-2007
+ * `$DWGCODEPAGE`: real ANSI multi-byte text essentially never forms valid
+ * UTF-8 sequences, while UTF-8 content always validates.
+ */
+function acdbIsValidUtf8(bytes) {
+    var n = bytes.length;
+    var i = 0;
+    while (i < n) {
+        var b0 = bytes[i];
+        if (b0 < 0x80) {
+            i++;
+            continue;
+        }
+        if (b0 < 0xc2)
+            return false; // stray continuation byte or overlong 2-byte lead
+        if (b0 < 0xe0) {
+            // 2-byte sequence
+            if (i + 1 >= n || (bytes[i + 1] & 0xc0) !== 0x80)
+                return false;
+            i += 2;
+            continue;
+        }
+        if (b0 < 0xf0) {
+            // 3-byte sequence
+            if (i + 2 >= n)
+                return false;
+            var b1 = bytes[i + 1];
+            if ((b1 & 0xc0) !== 0x80)
+                return false;
+            if (b0 === 0xe0 && b1 < 0xa0)
+                return false; // overlong encoding
+            if (b0 === 0xed && b1 >= 0xa0)
+                return false; // surrogate half
+            if ((bytes[i + 2] & 0xc0) !== 0x80)
+                return false;
+            i += 3;
+            continue;
+        }
+        if (b0 < 0xf5) {
+            // 4-byte sequence
+            if (i + 3 >= n)
+                return false;
+            var b1 = bytes[i + 1];
+            if ((b1 & 0xc0) !== 0x80)
+                return false;
+            if (b0 === 0xf0 && b1 < 0x90)
+                return false; // overlong encoding
+            if (b0 === 0xf4 && b1 >= 0x90)
+                return false; // beyond U+10FFFF
+            if ((bytes[i + 2] & 0xc0) !== 0x80)
+                return false;
+            if ((bytes[i + 3] & 0xc0) !== 0x80)
+                return false;
+            i += 4;
+            continue;
+        }
+        return false; // 0xf5..0xff are never valid lead bytes
+    }
+    return true;
+}
 /**
  * Create a pair reader from DXF bytes (ASCII or binary).
  *
- * ASCII path: peek HEADER for version/codepage when needed. UTF-8 drawings
- * decode one line-aligned window at a time (no full-file string). Legacy code
- * pages still decode once via `TextDecoder`, then scan with a character cursor.
+ * 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.
+ * 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).
  */
 export function acdbCreateDxfPairReader(data, options) {
     if (options === void 0) { options = {}; }
@@ -534,10 +1016,10 @@ export function acdbCreateDxfPairReader(data, options) {
         ? acdbNormalizeTextEncoding(options.encoding)
         : undefined;
     if (acdbIsBinaryDxf(bytes)) {
-        var encoding_1 = overrideEncoding;
+        var encoding = overrideEncoding;
         var legacyR12 = options.legacyR12;
-        if (encoding_1 == null || legacyR12 == null) {
-            encoding_1 = encoding_1 !== null && encoding_1 !== void 0 ? encoding_1 : 'utf-8';
+        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.
@@ -556,28 +1038,45 @@ export function acdbCreateDxfPairReader(data, options) {
                 }
             }
         }
-        return acdbMakeBinaryDxfPairReader(bytes, { encoding: encoding_1, legacyR12: legacyR12 });
+        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);
     }
-    var buffer = bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
-        ? bytes.buffer
-        : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-    var encoding = overrideEncoding;
-    if (encoding == null) {
+    // 2. Trust the bytes first: valid UTF-8 (including pure ASCII) is decoded
+    //    correctly no matter what a stale $DWGCODEPAGE claims, so modern files
+    //    never pay for a header pre-scan.
+    if (acdbIsValidUtf8(bytes)) {
+        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.
+    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);
-        // Pre-2007 drawings may declare a non-UTF-8 `$DWGCODEPAGE`.
         if (info.version &&
             !info.version.capabilities.supportsUtf8CodePage &&
             info.encoding) {
-            encoding = info.encoding;
-        }
-        else {
-            encoding = 'utf-8';
+            legacyEncoding = info.encoding;
         }
     }
-    if (isUtf8Encoding(encoding)) {
-        return acdbMakeUtf8AsciiDxfPairReader(bytes);
+    catch (_a) {
+        // 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);
     }
-    var text = new TextDecoder(encoding).decode(bytes);
-    return acdbMakeAsciiDxfPairReader(text);
+    return acdbMakeUtf8DxfPairReader(bytes);
 }
 //# sourceMappingURL=AcDbDxfPairReader.js.map