@node-projects/acad-ts 1.0.0

package/dist/IO/DWG/DwgStreamReaders/DwgStreamReaderBase.js

@@ -0,0 +1,734 @@
+import { XY, XYZ } from '../../../Math/index.js';
+import { Color } from '../../../Color.js';
+import { Transparency } from '../../../Transparency.js';
+import { ACadVersion } from '../../../ACadVersion.js';
+import { CadNotSupportedException } from '../../../Exceptions/CadNotSupportedException.js';
+import { DwgException } from '../../../Exceptions/DwgException.js';
+const _readerFactories = new Map();
+export function registerStreamReader(key, factory) {
+    _readerFactories.set(key, factory);
+}
+export class DwgStreamReaderBase {
+    bitShift = 0;
+    get position() {
+        return this._position;
+    }
+    set position(value) {
+        this._position = value;
+        this.bitShift = 0;
+    }
+    isEmpty = false;
+    encoding = 'utf-8';
+    get stream() {
+        return this._stream;
+    }
+    _stream;
+    _view;
+    _position;
+    _lastByte = 0;
+    constructor(stream, resetPosition) {
+        this._stream = stream;
+        this._view = new DataView(stream.buffer, stream.byteOffset, stream.byteLength);
+        this._position = resetPosition ? 0 : 0;
+    }
+    static getStreamHandler(version, stream, encoding, resetPosition = false) {
+        let reader;
+        let key;
+        switch (version) {
+            case ACadVersion.Unknown:
+            case ACadVersion.MC0_0:
+            case ACadVersion.AC1_2:
+            case ACadVersion.AC1_4:
+            case ACadVersion.AC1_50:
+            case ACadVersion.AC2_10:
+            case ACadVersion.AC1002:
+            case ACadVersion.AC1003:
+            case ACadVersion.AC1004:
+            case ACadVersion.AC1006:
+            case ACadVersion.AC1009:
+                throw new CadNotSupportedException(version);
+            case ACadVersion.AC1012:
+            case ACadVersion.AC1014:
+                key = 'AC12';
+                break;
+            case ACadVersion.AC1015:
+                key = 'AC15';
+                break;
+            case ACadVersion.AC1018:
+                key = 'AC18';
+                break;
+            case ACadVersion.AC1021:
+                key = 'AC21';
+                break;
+            case ACadVersion.AC1024:
+            case ACadVersion.AC1027:
+            case ACadVersion.AC1032:
+                key = 'AC24';
+                break;
+            default:
+                throw new CadNotSupportedException();
+        }
+        const Factory = _readerFactories.get(key);
+        if (!Factory) {
+            throw new Error(`DwgStreamReader factory for ${key} not registered. Import DwgStreamReaderFactory first.`);
+        }
+        reader = new Factory(stream, resetPosition);
+        if (encoding !== undefined) {
+            reader.encoding = encoding;
+        }
+        return reader;
+    }
+    // --- Base stream read methods ---
+    readByte() {
+        if (this.bitShift === 0) {
+            this._lastByte = this._stream[this._position++];
+            return this._lastByte;
+        }
+        const lastValues = (this._lastByte << this.bitShift) & 0xFF;
+        this._lastByte = this._stream[this._position++];
+        return (lastValues | (this._lastByte >>> (8 - this.bitShift))) & 0xFF;
+    }
+    readBytes(length) {
+        const numArray = new Uint8Array(length);
+        this.applyShiftToArr(length, numArray);
+        return numArray;
+    }
+    setPositionByFlag(position) {
+        this.setPositionInBits(position);
+        const flag = this.readBit();
+        let startPosition = position;
+        if (flag) {
+            const result = this.applyFlagToPosition(position);
+            startPosition = result.length - result.strDataSize;
+            this.setPositionInBits(startPosition);
+        }
+        else {
+            this.isEmpty = true;
+            this.position = this._stream.length;
+        }
+        return startPosition;
+    }
+    // --- BIT CODES AND DATA DEFINITIONS ---
+    readBit() {
+        if (this.bitShift === 0) {
+            this.advanceByte();
+            const result = (this._lastByte & 128) === 128;
+            this.bitShift = 1;
+            return result;
+        }
+        const value = ((this._lastByte << this.bitShift) & 128) === 128;
+        ++this.bitShift;
+        this.bitShift &= 7;
+        return value;
+    }
+    readBitAsShort() {
+        return this.readBit() ? 1 : 0;
+    }
+    read2Bits() {
+        let value;
+        if (this.bitShift === 0) {
+            this.advanceByte();
+            value = this._lastByte >>> 6;
+            this.bitShift = 2;
+        }
+        else if (this.bitShift === 7) {
+            const lastValue = (this._lastByte << 1) & 2;
+            this.advanceByte();
+            value = lastValue | (this._lastByte >>> 7);
+            this.bitShift = 1;
+        }
+        else {
+            value = (this._lastByte >>> (6 - this.bitShift)) & 3;
+            ++this.bitShift;
+            ++this.bitShift;
+            this.bitShift &= 7;
+        }
+        return value;
+    }
+    readBitShort() {
+        let value;
+        switch (this.read2Bits()) {
+            case 0:
+                value = this.readShortLittleEndian();
+                break;
+            case 1:
+                if (this.bitShift === 0) {
+                    this.advanceByte();
+                    value = this._lastByte;
+                    break;
+                }
+                value = this.applyShiftToLastByte();
+                break;
+            case 2:
+                value = 0;
+                break;
+            case 3:
+                value = 256;
+                break;
+            default:
+                throw this.throwException('ReadBitShort');
+        }
+        // Sign-extend to short
+        if (value > 32767)
+            value -= 65536;
+        return value;
+    }
+    readBitShortAsBool() {
+        return this.readBitShort() !== 0;
+    }
+    readBitLong() {
+        let value;
+        switch (this.read2Bits()) {
+            case 0:
+                value = this.readIntLittleEndian();
+                break;
+            case 1:
+                if (this.bitShift === 0) {
+                    this.advanceByte();
+                    value = this._lastByte;
+                    break;
+                }
+                value = this.applyShiftToLastByte();
+                break;
+            case 2:
+                value = 0;
+                break;
+            default:
+                throw new Error('Failed to read ReadBitLong');
+        }
+        return value;
+    }
+    readBitLongLong() {
+        let value = 0;
+        const size = this.read3bits();
+        for (let i = 0; i < size; ++i) {
+            const b = this.readByte();
+            value += b << (i << 3);
+        }
+        return value;
+    }
+    readBitDouble() {
+        let value;
+        switch (this.read2Bits()) {
+            case 0:
+                value = this.readDoubleLittleEndian();
+                break;
+            case 1:
+                value = 1.0;
+                break;
+            case 2:
+                value = 0.0;
+                break;
+            default:
+                throw this.throwException('ReadBitDouble');
+        }
+        return value;
+    }
+    read2BitDouble() {
+        return new XY(this.readBitDouble(), this.readBitDouble());
+    }
+    read3BitDouble() {
+        return new XYZ(this.readBitDouble(), this.readBitDouble(), this.readBitDouble());
+    }
+    readRawChar() {
+        return this.readByte();
+    }
+    readRawLong() {
+        return this.readIntLittleEndian();
+    }
+    readRawULong() {
+        return this.readULongLittleEndian();
+    }
+    read2RawDouble() {
+        return new XY(this.readDouble(), this.readDouble());
+    }
+    read3RawDouble() {
+        return new XYZ(this.readDouble(), this.readDouble(), this.readDouble());
+    }
+    readModularChar() {
+        let shift = 0;
+        let lastByte = this.readByte();
+        let value = lastByte & 0b01111111;
+        if ((lastByte & 0b10000000) !== 0) {
+            while (true) {
+                shift += 7;
+                const last = this.readByte();
+                value |= (last & 0b01111111) << shift;
+                if ((last & 0b10000000) === 0) {
+                    break;
+                }
+            }
+        }
+        return value;
+    }
+    readSignedModularChar() {
+        let value;
+        if (this.bitShift === 0) {
+            this.advanceByte();
+            if ((this._lastByte & 0b10000000) === 0) {
+                value = this._lastByte & 0b00111111;
+                if ((this._lastByte & 0b01000000) > 0) {
+                    value = -value;
+                }
+            }
+            else {
+                let totalShift = 0;
+                let sum = this._lastByte & 0x7F;
+                while (true) {
+                    totalShift += 7;
+                    this.advanceByte();
+                    if ((this._lastByte & 0b10000000) !== 0) {
+                        sum |= (this._lastByte & 0x7F) << totalShift;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                value = sum | ((this._lastByte & 0b00111111) << totalShift);
+                if ((this._lastByte & 0b01000000) > 0) {
+                    value = -value;
+                }
+            }
+        }
+        else {
+            let lastByte = this.applyShiftToLastByte();
+            if ((lastByte & 0b10000000) === 0) {
+                value = lastByte & 0b00111111;
+                if ((lastByte & 0b01000000) > 0) {
+                    value = -value;
+                }
+            }
+            else {
+                let totalShift = 0;
+                let sum = lastByte & 0x7F;
+                let currByte;
+                while (true) {
+                    totalShift += 7;
+                    currByte = this.applyShiftToLastByte();
+                    if ((currByte & 0b10000000) !== 0) {
+                        sum |= (currByte & 0x7F) << totalShift;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                value = sum | ((currByte & 0b00111111) << totalShift);
+                if ((currByte & 0b01000000) > 0) {
+                    value = -value;
+                }
+            }
+        }
+        return value;
+    }
+    readModularShort() {
+        let shift = 0b1111;
+        let b1 = this.readByte();
+        let b2 = this.readByte();
+        let flag = (b2 & 0b10000000) === 0;
+        let value = b1 | ((b2 & 0b1111111) << 8);
+        while (!flag) {
+            b1 = this.readByte();
+            b2 = this.readByte();
+            flag = (b2 & 0b10000000) === 0;
+            value |= b1 << shift;
+            shift += 8;
+            value |= (b2 & 0b1111111) << shift;
+            shift += 7;
+        }
+        return value;
+    }
+    // --- Handle reference ---
+    handleReference() {
+        return this.handleReferenceWithRefAndType(0).handle;
+    }
+    handleReferenceWithRef(referenceHandle) {
+        return this.handleReferenceWithRefAndType(referenceHandle).handle;
+    }
+    handleReferenceWithRefAndType(referenceHandle) {
+        const form = this.readByte();
+        const code = form >>> 4;
+        const counter = form & 0b00001111;
+        const reference = (code & 0b0011);
+        let initialPos;
+        if (code <= 0x5) {
+            initialPos = this.readHandle(counter);
+        }
+        else if (code === 0x6) {
+            initialPos = referenceHandle + 1;
+        }
+        else if (code === 0x8) {
+            initialPos = referenceHandle - 1;
+        }
+        else if (code === 0xA) {
+            const offset = this.readHandle(counter);
+            initialPos = referenceHandle + offset;
+        }
+        else if (code === 0xC) {
+            const offset = this.readHandle(counter);
+            initialPos = referenceHandle - offset;
+        }
+        else {
+            throw new DwgException(`[HandleReference] invalid reference code with value: ${code}`);
+        }
+        return { handle: initialPos, reference };
+    }
+    readHandle(length) {
+        const raw = new Uint8Array(length);
+        const arr = new Uint8Array(8);
+        for (let i = 0; i < length; i++) {
+            raw[i] = this._stream[this._position++];
+        }
+        if (this.bitShift === 0) {
+            for (let i = 0; i < length; ++i) {
+                arr[length - 1 - i] = raw[i];
+            }
+        }
+        else {
+            const shift = 8 - this.bitShift;
+            for (let i = 0; i < length; ++i) {
+                const lastByteValue = (this._lastByte << this.bitShift) & 0xFF;
+                this._lastByte = raw[i];
+                const value = (lastByteValue | (this._lastByte >>> shift)) & 0xFF;
+                arr[length - 1 - i] = value;
+            }
+        }
+        for (let index = length; index < 8; ++index) {
+            arr[index] = 0;
+        }
+        // Read as little-endian uint64 (but we only support up to 53-bit safe range)
+        const view = new DataView(arr.buffer);
+        const lo = view.getUint32(0, true);
+        const hi = view.getUint32(4, true);
+        return lo + hi * 0x100000000;
+    }
+    // --- Text ---
+    readTextUnicode() {
+        const textLength = this.readShort();
+        const encodingKey = this.readByte();
+        let value;
+        if (textLength === 0) {
+            value = '';
+        }
+        else {
+            value = this.readStringEncoded(textLength, this.getEncodingFromCodePage(encodingKey));
+        }
+        return value;
+    }
+    readVariableText() {
+        const length = this.readBitShort();
+        let str;
+        if (length > 0) {
+            str = this.readStringEncoded(length, this.encoding).replace(/\0/g, '');
+        }
+        else {
+            str = '';
+        }
+        return str;
+    }
+    readSentinel() {
+        return this.readBytes(16);
+    }
+    read2BitDoubleWithDefault(defValues) {
+        return new XY(this.readBitDoubleWithDefault(defValues.x), this.readBitDoubleWithDefault(defValues.y));
+    }
+    read3BitDoubleWithDefault(defValues) {
+        return new XYZ(this.readBitDoubleWithDefault(defValues.x), this.readBitDoubleWithDefault(defValues.y), this.readBitDoubleWithDefault(defValues.z));
+    }
+    readCmColor(_useTextStream = false) {
+        const colorIndex = this.readBitShort();
+        return new Color(colorIndex);
+    }
+    readEnColor() {
+        const colorNumber = this.readBitShort();
+        return {
+            color: new Color(colorNumber),
+            transparency: Transparency.ByLayer,
+            flag: false,
+        };
+    }
+    readColorByIndex() {
+        return new Color(this.readBitShort());
+    }
+    readObjectType() {
+        return this.readBitShort();
+    }
+    readBitExtrusion() {
+        return this.read3BitDouble();
+    }
+    readBitDoubleWithDefault(def) {
+        const arr = new Uint8Array(8);
+        const defView = new DataView(new ArrayBuffer(8));
+        defView.setFloat64(0, def, true);
+        for (let i = 0; i < 8; i++) {
+            arr[i] = new Uint8Array(defView.buffer)[i];
+        }
+        switch (this.read2Bits()) {
+            case 0:
+                return def;
+            case 1:
+                if (this.bitShift === 0) {
+                    this.advanceByte();
+                    arr[0] = this._lastByte;
+                    this.advanceByte();
+                    arr[1] = this._lastByte;
+                    this.advanceByte();
+                    arr[2] = this._lastByte;
+                    this.advanceByte();
+                    arr[3] = this._lastByte;
+                }
+                else {
+                    const shift = 8 - this.bitShift;
+                    arr[0] = (this._lastByte << this.bitShift) & 0xFF;
+                    this.advanceByte();
+                    arr[0] = (arr[0] | (this._lastByte >>> shift)) & 0xFF;
+                    arr[1] = (this._lastByte << this.bitShift) & 0xFF;
+                    this.advanceByte();
+                    arr[1] = (arr[1] | (this._lastByte >>> shift)) & 0xFF;
+                    arr[2] = (this._lastByte << this.bitShift) & 0xFF;
+                    this.advanceByte();
+                    arr[2] = (arr[2] | (this._lastByte >>> shift)) & 0xFF;
+                    arr[3] = (this._lastByte << this.bitShift) & 0xFF;
+                    this.advanceByte();
+                    arr[3] = (arr[3] | (this._lastByte >>> shift)) & 0xFF;
+                }
+                return new DataView(arr.buffer).getFloat64(0, true);
+            case 2:
+                if (this.bitShift === 0) {
+                    this.advanceByte();
+                    arr[4] = this._lastByte;
+                    this.advanceByte();
+                    arr[5] = this._lastByte;
+                    this.advanceByte();
+                    arr[0] = this._lastByte;
+                    this.advanceByte();
+                    arr[1] = this._lastByte;
+                    this.advanceByte();
+                    arr[2] = this._lastByte;
+                    this.advanceByte();
+                    arr[3] = this._lastByte;
+                }
+                else {
+                    const shift = 8 - this.bitShift;
+                    arr[4] = (this._lastByte << this.bitShift) & 0xFF;
+                    this.advanceByte();
+                    arr[4] = (arr[4] | (this._lastByte >>> shift)) & 0xFF;
+                    arr[5] = (this._lastByte << this.bitShift) & 0xFF;
+                    this.advanceByte();
+                    arr[5] = (arr[5] | (this._lastByte >>> shift)) & 0xFF;
+                    arr[0] = (this._lastByte << this.bitShift) & 0xFF;
+                    this.advanceByte();
+                    arr[0] = (arr[0] | (this._lastByte >>> shift)) & 0xFF;
+                    arr[1] = (this._lastByte << this.bitShift) & 0xFF;
+                    this.advanceByte();
+                    arr[1] = (arr[1] | (this._lastByte >>> shift)) & 0xFF;
+                    arr[2] = (this._lastByte << this.bitShift) & 0xFF;
+                    this.advanceByte();
+                    arr[2] = (arr[2] | (this._lastByte >>> shift)) & 0xFF;
+                    arr[3] = (this._lastByte << this.bitShift) & 0xFF;
+                    this.advanceByte();
+                    arr[3] = (arr[3] | (this._lastByte >>> shift)) & 0xFF;
+                }
+                return new DataView(arr.buffer).getFloat64(0, true);
+            case 3:
+                return this.readDouble();
+            default:
+                throw this.throwException('ReadBitDoubleWithDefault');
+        }
+    }
+    readBitThickness() {
+        return this.readBitDouble();
+    }
+    // --- Date/Time ---
+    read8BitJulianDate() {
+        return this.julianToDate(this.readInt(), this.readInt());
+    }
+    readDateTime() {
+        return this.julianToDate(this.readBitLong(), this.readBitLong());
+    }
+    readTimeSpan() {
+        const hours = this.readBitLong();
+        const milliseconds = this.readBitLong();
+        return hours * 3600000 + milliseconds;
+    }
+    // --- Stream pointer control ---
+    positionInBits() {
+        let bitPosition = this._position * 8;
+        if (this.bitShift > 0) {
+            bitPosition += this.bitShift - 8;
+        }
+        return bitPosition;
+    }
+    setPositionInBits(position) {
+        this.position = position >> 3;
+        this.bitShift = position & 7;
+        if (this.bitShift <= 0) {
+            return;
+        }
+        this.advanceByte();
+    }
+    advanceByte() {
+        this._lastByte = this._stream[this._position++];
+    }
+    advance(offset) {
+        if (offset > 1) {
+            this._position += offset - 1;
+        }
+        this.readByte();
+    }
+    resetShift() {
+        if (this.bitShift > 0) {
+            this.bitShift = 0;
+        }
+        this.advanceByte();
+        let num = this._lastByte;
+        this.advanceByte();
+        return (num | (this._lastByte << 8)) & 0xFFFF;
+    }
+    // --- Low-level read helpers ---
+    readShort() {
+        const b0 = this.readByte();
+        const b1 = this.readByte();
+        let value = b0 | (b1 << 8);
+        if (value > 32767)
+            value -= 65536;
+        return value;
+    }
+    readShortLittleEndian() {
+        return this.readShort();
+    }
+    readShortBigEndian() {
+        const b0 = this.readByte();
+        const b1 = this.readByte();
+        let value = (b0 << 8) | b1;
+        if (value > 32767)
+            value -= 65536;
+        return value;
+    }
+    readInt() {
+        const b0 = this.readByte();
+        const b1 = this.readByte();
+        const b2 = this.readByte();
+        const b3 = this.readByte();
+        return b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
+    }
+    readIntLittleEndian() {
+        return this.readInt();
+    }
+    readUInt() {
+        return this.readInt() >>> 0;
+    }
+    readDouble() {
+        const bytes = this.readBytes(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, 8);
+        return view.getFloat64(0, true);
+    }
+    readDoubleLittleEndian() {
+        return this.readDouble();
+    }
+    readUShort() {
+        const b0 = this.readByte();
+        const b1 = this.readByte();
+        return (b0 | (b1 << 8)) & 0xFFFF;
+    }
+    readULongLittleEndian() {
+        const b0 = this.readByte();
+        const b1 = this.readByte();
+        const b2 = this.readByte();
+        const b3 = this.readByte();
+        const b4 = this.readByte();
+        const b5 = this.readByte();
+        const b6 = this.readByte();
+        const b7 = this.readByte();
+        const lo = (b0 | (b1 << 8) | (b2 << 16) | (b3 << 24)) >>> 0;
+        const hi = (b4 | (b5 << 8) | (b6 << 16) | (b7 << 24)) >>> 0;
+        return lo + hi * 0x100000000;
+    }
+    readStringEncoded(length, encoding) {
+        const bytes = this.readBytes(length);
+        const decoder = new TextDecoder(encoding);
+        return decoder.decode(bytes);
+    }
+    // --- Protected helpers ---
+    applyFlagToPosition(lastPos) {
+        let length = lastPos - 16;
+        this.setPositionInBits(length);
+        let strDataSize = this.readUShort();
+        if ((strDataSize & 0x8000) > 0) {
+            length -= 16;
+            this.setPositionInBits(length);
+            strDataSize &= 0x7FFF;
+            const hiSize = this.readUShort();
+            strDataSize += (hiSize & 0xFFFF) << 15;
+        }
+        return { length, strDataSize };
+    }
+    applyShiftToLastByte() {
+        let value = (this._lastByte << this.bitShift) & 0xFF;
+        this.advanceByte();
+        return (value | (this._lastByte >>> (8 - this.bitShift))) & 0xFF;
+    }
+    throwException(callerName) {
+        return new DwgException(`Failed to read ${callerName || 'unknown'}`);
+    }
+    applyShiftToArr(length, arr) {
+        for (let i = 0; i < length; i++) {
+            arr[i] = this._stream[this._position++];
+        }
+        if (this.bitShift <= 0) {
+            return;
+        }
+        const shift = 8 - this.bitShift;
+        for (let i = 0; i < length; ++i) {
+            const lastByteValue = (this._lastByte << this.bitShift) & 0xFF;
+            this._lastByte = arr[i];
+            const value = (lastByteValue | (this._lastByte >>> shift)) & 0xFF;
+            arr[i] = value;
+        }
+    }
+    read3bits() {
+        let b1 = 0;
+        if (this.readBit())
+            b1 = 1;
+        let b2 = (b1 << 1) & 0xFF;
+        if (this.readBit())
+            b2 |= 1;
+        let b3 = (b2 << 1) & 0xFF;
+        if (this.readBit())
+            b3 |= 1;
+        return b3;
+    }
+    julianToDate(jdate, milliseconds) {
+        const unixTime = (jdate - 2440587.5) * 86400;
+        try {
+            const dt = new Date(unixTime * 1000 + milliseconds);
+            return dt;
+        }
+        catch {
+            return new Date(0);
+        }
+    }
+    getEncodingFromCodePage(codePage) {
+        // Map common Windows code pages to TextDecoder encoding labels
+        switch (codePage) {
+            case 0: return 'utf-8';
+            case 1: return 'ascii';
+            case 28591: return 'iso-8859-1';
+            case 1252: return 'windows-1252';
+            case 1250: return 'windows-1250';
+            case 1251: return 'windows-1251';
+            case 1253: return 'windows-1253';
+            case 1254: return 'windows-1254';
+            case 1255: return 'windows-1255';
+            case 1256: return 'windows-1256';
+            case 1257: return 'windows-1257';
+            case 1258: return 'windows-1258';
+            case 932: return 'shift_jis';
+            case 936: return 'gb2312';
+            case 949: return 'euc-kr';
+            case 950: return 'big5';
+            case 65001: return 'utf-8';
+            default: return 'windows-1252';
+        }
+    }
+}
+//# sourceMappingURL=DwgStreamReaderBase.js.map