ofs-dxf-ts 1.0.0

package/dist/parser/dxf-parser.js

@@ -0,0 +1,824 @@
+/**
+ * DxfParser — TypeScript port of the `dxf-parser` package (see parser-raw/
+ * for the original JS source). Parses a DXF string into structured data:
+ * header, tables (layers, line types, styles, …), blocks and entities.
+ *
+ * Browser-first: only `parseSync(source: string)` is provided (the original's
+ * Node-stream `parseStream` was dropped).
+ */
+import DxfArrayScanner from './scanner.js';
+import AUTO_CAD_COLOR_INDEX from './auto-cad-color-index.js';
+import dimStyleCodes from './dim-style-codes.js';
+import log from './log.js';
+import Face from './entities/3dface.js';
+import Arc from './entities/arc.js';
+import AttDef from './entities/attdef.js';
+import Attribute from './entities/attribute.js';
+import Circle from './entities/circle.js';
+import Dimension from './entities/dimension.js';
+import Ellipse from './entities/ellipse.js';
+import Insert from './entities/insert.js';
+import Line from './entities/line.js';
+import LWPolyline from './entities/lwpolyline.js';
+import MText from './entities/mtext.js';
+import Point from './entities/point.js';
+import Polyline from './entities/polyline.js';
+import Solid from './entities/solid.js';
+import Spline from './entities/spline.js';
+import Text from './entities/text.js';
+import Hatch from './entities/hatch.js';
+function registerDefaultEntityHandlers(dxfParser) {
+    // Supported entities here (some entity code is still being refactored into this flow)
+    dxfParser.registerEntityHandler(Face);
+    dxfParser.registerEntityHandler(Arc);
+    dxfParser.registerEntityHandler(AttDef);
+    dxfParser.registerEntityHandler(Attribute);
+    dxfParser.registerEntityHandler(Circle);
+    dxfParser.registerEntityHandler(Dimension);
+    dxfParser.registerEntityHandler(Ellipse);
+    dxfParser.registerEntityHandler(Insert);
+    dxfParser.registerEntityHandler(Line);
+    dxfParser.registerEntityHandler(LWPolyline);
+    dxfParser.registerEntityHandler(MText);
+    dxfParser.registerEntityHandler(Point);
+    dxfParser.registerEntityHandler(Polyline);
+    dxfParser.registerEntityHandler(Solid);
+    dxfParser.registerEntityHandler(Spline);
+    dxfParser.registerEntityHandler(Text);
+    dxfParser.registerEntityHandler(Hatch);
+}
+export default class DxfParser {
+    _entityHandlers = {};
+    constructor() {
+        registerDefaultEntityHandlers(this);
+    }
+    registerEntityHandler(handlerType) {
+        this._entityHandlers[handlerType.ForEntityName] = new handlerType();
+    }
+    parseSync(source) {
+        if (typeof source === 'string') {
+            return this._parse(source);
+        }
+        else {
+            console.error('Cannot read DXF source of type `' + typeof source);
+            return null;
+        }
+    }
+    _parse(dxfString) {
+        const dxf = {};
+        let lastHandle = 0;
+        const dxfLinesArray = dxfString.split(/\r\n|\r|\n/g);
+        const scanner = new DxfArrayScanner(dxfLinesArray);
+        if (!scanner.hasNext()) {
+            throw Error('Empty file');
+        }
+        let curr;
+        const self = this;
+        const parseAll = () => {
+            curr = scanner.next();
+            while (!scanner.isEOF()) {
+                if (curr.code === 0 && curr.value === 'SECTION') {
+                    curr = scanner.next();
+                    // Be sure we are reading a section code
+                    if (curr.code !== 2) {
+                        console.error('Unexpected code %s after 0:SECTION', debugCode(curr));
+                        curr = scanner.next();
+                        continue;
+                    }
+                    if (curr.value === 'HEADER') {
+                        log.debug('> HEADER');
+                        dxf.header = parseHeader();
+                        log.debug('<');
+                    }
+                    else if (curr.value === 'BLOCKS') {
+                        log.debug('> BLOCKS');
+                        dxf.blocks = parseBlocks();
+                        log.debug('<');
+                    }
+                    else if (curr.value === 'ENTITIES') {
+                        log.debug('> ENTITIES');
+                        dxf.entities = parseEntities(false);
+                        log.debug('<');
+                    }
+                    else if (curr.value === 'TABLES') {
+                        log.debug('> TABLES');
+                        dxf.tables = parseTables();
+                        log.debug('<');
+                    }
+                    else if (curr.value === 'EOF') {
+                        log.debug('EOF');
+                    }
+                    else {
+                        log.warn(`Skipping section '${curr.value}'`);
+                    }
+                }
+                else {
+                    curr = scanner.next();
+                }
+                // If is a new section
+            }
+        };
+        const groupIs = (code, value) => {
+            return curr.code === code && curr.value === value;
+        };
+        /**
+         * @return header
+         */
+        const parseHeader = () => {
+            // interesting variables:
+            //  $ACADVER, $VIEWDIR, $VIEWSIZE, $VIEWCTR, $TDCREATE, $TDUPDATE
+            // http://www.autodesk.com/techpubs/autocad/acadr14/dxf/header_section_al_u05_c.htm
+            // Also see VPORT table entries
+            let currVarName = null;
+            let currVarValue = null;
+            const header = {};
+            // loop through header variables
+            curr = scanner.next();
+            while (true) {
+                if (groupIs(0, 'ENDSEC')) {
+                    if (currVarName != null)
+                        header[currVarName] = currVarValue;
+                    break;
+                }
+                else if (curr.code === 9) {
+                    if (currVarName != null)
+                        header[currVarName] = currVarValue;
+                    currVarName = curr.value;
+                    // Filter here for particular variables we are interested in
+                }
+                else {
+                    if (curr.code === 10) {
+                        currVarValue = { x: curr.value };
+                    }
+                    else if (curr.code === 20) {
+                        currVarValue.y = curr.value;
+                    }
+                    else if (curr.code === 30) {
+                        currVarValue.z = curr.value;
+                    }
+                    else {
+                        currVarValue = curr.value;
+                    }
+                }
+                curr = scanner.next();
+            }
+            curr = scanner.next(); // swallow up ENDSEC
+            return header;
+        };
+        const parseBlocks = () => {
+            const blocks = {};
+            curr = scanner.next();
+            while (curr.value !== 'EOF') {
+                if (groupIs(0, 'ENDSEC')) {
+                    break;
+                }
+                if (groupIs(0, 'BLOCK')) {
+                    log.debug('block {');
+                    const block = parseBlock();
+                    log.debug('}');
+                    ensureHandle(block);
+                    if (!block.name)
+                        log.error('block with handle "' + block.handle + '" is missing a name.');
+                    else
+                        blocks[block.name] = block;
+                }
+                else {
+                    logUnhandledGroup(curr);
+                    curr = scanner.next();
+                }
+            }
+            return blocks;
+        };
+        const parseBlock = () => {
+            const block = {};
+            curr = scanner.next();
+            while (curr.value !== 'EOF') {
+                switch (curr.code) {
+                    case 1:
+                        block.xrefPath = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 2:
+                        block.name = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 3:
+                        block.name2 = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 5:
+                        block.handle = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 8:
+                        block.layer = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 10:
+                        block.position = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 67:
+                        block.inPaperSpace = (curr.value && curr.value == 1) ? true : false;
+                        curr = scanner.next();
+                        break;
+                    case 70:
+                        if (curr.value != 0) {
+                            //if(curr.value & BLOCK_ANONYMOUS_FLAG) console.log('  Anonymous block');
+                            //if(curr.value & BLOCK_NON_CONSTANT_FLAG) console.log('  Non-constant attributes');
+                            //if(curr.value & BLOCK_XREF_FLAG) console.log('  Is xref');
+                            //if(curr.value & BLOCK_XREF_OVERLAY_FLAG) console.log('  Is xref overlay');
+                            //if(curr.value & BLOCK_EXTERNALLY_DEPENDENT_FLAG) console.log('  Is externally dependent');
+                            //if(curr.value & BLOCK_RESOLVED_OR_DEPENDENT_FLAG) console.log('  Is resolved xref or dependent of an xref');
+                            //if(curr.value & BLOCK_REFERENCED_XREF) console.log('  This definition is a referenced xref');
+                            block.type = curr.value;
+                        }
+                        curr = scanner.next();
+                        break;
+                    case 100:
+                        // ignore class markers
+                        curr = scanner.next();
+                        break;
+                    case 330:
+                        block.ownerHandle = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 0:
+                        if (curr.value == 'ENDBLK')
+                            break;
+                        block.entities = parseEntities(true);
+                        break;
+                    default:
+                        logUnhandledGroup(curr);
+                        curr = scanner.next();
+                }
+                if (groupIs(0, 'ENDBLK')) {
+                    curr = scanner.next();
+                    break;
+                }
+            }
+            return block;
+        };
+        /**
+         * parseTables
+         * @return Object representing tables
+         */
+        const parseTables = () => {
+            const tables = {};
+            curr = scanner.next();
+            while (curr.value !== 'EOF') {
+                if (groupIs(0, 'ENDSEC'))
+                    break;
+                if (groupIs(0, 'TABLE')) {
+                    curr = scanner.next();
+                    const tableDefinition = tableDefinitions[curr.value];
+                    if (tableDefinition) {
+                        log.debug(curr.value + ' Table {');
+                        tables[tableDefinitions[curr.value].tableName] = parseTable();
+                        log.debug('}');
+                    }
+                    else {
+                        log.debug('Unhandled Table ' + curr.value);
+                    }
+                }
+                else {
+                    // else ignored
+                    curr = scanner.next();
+                }
+            }
+            curr = scanner.next();
+            return tables;
+        };
+        const END_OF_TABLE_VALUE = 'ENDTAB';
+        const parseTable = () => {
+            const tableDefinition = tableDefinitions[curr.value];
+            const table = {};
+            let expectedCount = 0;
+            let actualCount;
+            curr = scanner.next();
+            while (!groupIs(0, END_OF_TABLE_VALUE)) {
+                switch (curr.code) {
+                    case 5:
+                        table.handle = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 330:
+                        table.ownerHandle = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 100:
+                        if (curr.value === 'AcDbSymbolTable') {
+                            // ignore
+                            curr = scanner.next();
+                        }
+                        else {
+                            logUnhandledGroup(curr);
+                            curr = scanner.next();
+                        }
+                        break;
+                    case 70:
+                        expectedCount = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 0:
+                        if (curr.value === tableDefinition.dxfSymbolName) {
+                            table[tableDefinition.tableRecordsProperty] = tableDefinition.parseTableRecords();
+                        }
+                        else {
+                            logUnhandledGroup(curr);
+                            curr = scanner.next();
+                        }
+                        break;
+                    default:
+                        logUnhandledGroup(curr);
+                        curr = scanner.next();
+                }
+            }
+            const tableRecords = table[tableDefinition.tableRecordsProperty];
+            if (tableRecords) {
+                if (tableRecords.constructor === Array) {
+                    actualCount = tableRecords.length;
+                }
+                else if (typeof tableRecords === 'object') {
+                    actualCount = Object.keys(tableRecords).length;
+                }
+                if (expectedCount !== actualCount) {
+                    log.warn(`Parsed ${actualCount} ${tableDefinition.dxfSymbolName}'s but expected ${expectedCount}`);
+                }
+            }
+            else {
+                table[tableDefinition.tableRecordsProperty] = [];
+            }
+            curr = scanner.next();
+            return table;
+        };
+        const parseViewPortRecords = () => {
+            const viewPorts = []; // Multiple table entries may have the same name indicating a multiple viewport configuration
+            let viewPort = {};
+            log.debug('ViewPort {');
+            curr = scanner.next();
+            while (!groupIs(0, END_OF_TABLE_VALUE)) {
+                switch (curr.code) {
+                    case 2: // layer name
+                        viewPort.name = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 10:
+                        viewPort.lowerLeftCorner = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 11:
+                        viewPort.upperRightCorner = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 12:
+                        viewPort.center = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 13:
+                        viewPort.snapBasePoint = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 14:
+                        viewPort.snapSpacing = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 15:
+                        viewPort.gridSpacing = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 16:
+                        viewPort.viewDirectionFromTarget = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 17:
+                        viewPort.viewTarget = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 42:
+                        viewPort.lensLength = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 43:
+                        viewPort.frontClippingPlane = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 44:
+                        viewPort.backClippingPlane = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 45:
+                        viewPort.viewHeight = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 50:
+                        viewPort.snapRotationAngle = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 51:
+                        viewPort.viewTwistAngle = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 79:
+                        viewPort.orthographicType = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 110:
+                        viewPort.ucsOrigin = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 111:
+                        viewPort.ucsXAxis = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 112:
+                        viewPort.ucsYAxis = parsePoint();
+                        curr = scanner.next();
+                        break;
+                    case 281:
+                        // Note: the original parser also mapped 281 to
+                        // defaultLightingType (0 = one distant light, 1 = two
+                        // distant lights) in a duplicate, unreachable case.
+                        viewPort.renderMode = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 292:
+                        viewPort.defaultLightingOn = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 330:
+                        viewPort.ownerHandle = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 63: // These are all ambient color. Perhaps should be a gradient when multiple are set.
+                    case 421:
+                    case 431:
+                        viewPort.ambientColor = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 0:
+                        // New ViewPort
+                        if (curr.value === 'VPORT') {
+                            log.debug('}');
+                            viewPorts.push(viewPort);
+                            log.debug('ViewPort {');
+                            viewPort = {};
+                            curr = scanner.next();
+                        }
+                        break;
+                    default:
+                        logUnhandledGroup(curr);
+                        curr = scanner.next();
+                        break;
+                }
+            }
+            // Note: do not call scanner.next() here,
+            //  parseTable() needs the current group
+            log.debug('}');
+            viewPorts.push(viewPort);
+            return viewPorts;
+        };
+        const parseLineTypes = () => {
+            const ltypes = {};
+            let ltypeName;
+            let ltype = {};
+            let length = 0;
+            log.debug('LType {');
+            curr = scanner.next();
+            while (!groupIs(0, 'ENDTAB')) {
+                switch (curr.code) {
+                    case 2:
+                        ltype.name = curr.value;
+                        ltypeName = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 3:
+                        ltype.description = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 73: // Number of elements for this line type (dots, dashes, spaces);
+                        length = curr.value;
+                        if (length > 0)
+                            ltype.pattern = [];
+                        curr = scanner.next();
+                        break;
+                    case 40: // total pattern length
+                        ltype.patternLength = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 49:
+                        ltype.pattern.push(curr.value);
+                        curr = scanner.next();
+                        break;
+                    case 0:
+                        log.debug('}');
+                        if (length > 0 && length !== ltype.pattern.length) {
+                            log.warn('lengths do not match on LTYPE pattern');
+                        }
+                        ltypes[ltypeName] = ltype;
+                        ltype = {};
+                        log.debug('LType {');
+                        curr = scanner.next();
+                        break;
+                    default:
+                        curr = scanner.next();
+                }
+            }
+            log.debug('}');
+            ltypes[ltypeName] = ltype;
+            return ltypes;
+        };
+        const parseLayers = () => {
+            const layers = {};
+            let layerName;
+            let layer = {};
+            log.debug('Layer {');
+            curr = scanner.next();
+            while (!groupIs(0, 'ENDTAB')) {
+                switch (curr.code) {
+                    case 2: // layer name
+                        layer.name = curr.value;
+                        layerName = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 62: // color, visibility
+                        layer.visible = curr.value >= 0;
+                        // TODO 0 and 256 are BYBLOCK and BYLAYER respectively. Need to handle these values for layers?.
+                        layer.colorIndex = Math.abs(curr.value);
+                        layer.color = getAcadColor(layer.colorIndex);
+                        curr = scanner.next();
+                        break;
+                    case 70: // frozen layer
+                        layer.frozen = ((curr.value & 1) !== 0 || (curr.value & 2) !== 0);
+                        curr = scanner.next();
+                        break;
+                    case 420: // TrueColor Color
+                        layer.color = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 0:
+                        // New Layer
+                        if (curr.value === 'LAYER') {
+                            log.debug('}');
+                            layers[layerName] = layer;
+                            log.debug('Layer {');
+                            layer = {};
+                            layerName = undefined;
+                            curr = scanner.next();
+                        }
+                        break;
+                    default:
+                        logUnhandledGroup(curr);
+                        curr = scanner.next();
+                        break;
+                }
+            }
+            // Note: do not call scanner.next() here,
+            //  parseLayerTable() needs the current group
+            log.debug('}');
+            layers[layerName] = layer;
+            return layers;
+        };
+        const parseDimStyles = () => {
+            const dimStyles = {};
+            let styleName;
+            let style = {};
+            log.debug('DimStyle {');
+            curr = scanner.next();
+            while (!groupIs(0, 'ENDTAB')) {
+                if (dimStyleCodes.has(curr.code)) {
+                    style[dimStyleCodes.get(curr.code)] = curr.value;
+                    curr = scanner.next();
+                }
+                else {
+                    switch (curr.code) {
+                        case 2: // style name
+                            style.name = curr.value;
+                            styleName = curr.value;
+                            curr = scanner.next();
+                            break;
+                        case 0:
+                            // New style
+                            if (curr.value === 'DIMSTYLE') {
+                                log.debug('}');
+                                dimStyles[styleName] = style;
+                                log.debug('DimStyle {');
+                                style = {};
+                                styleName = undefined;
+                                curr = scanner.next();
+                            }
+                            break;
+                        default:
+                            logUnhandledGroup(curr);
+                            curr = scanner.next();
+                            break;
+                    }
+                }
+            }
+            // Note: do not call scanner.next() here,
+            //  parseLayerTable() needs the current group
+            log.debug('}');
+            dimStyles[styleName] = style;
+            return dimStyles;
+        };
+        const parseStyles = () => {
+            const styles = {};
+            let style = {};
+            let styleName;
+            log.debug('Style {');
+            curr = scanner.next();
+            while (!groupIs(0, END_OF_TABLE_VALUE)) {
+                switch (curr.code) {
+                    case 100:
+                        style.subClassMarker = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 2:
+                        style.styleName = curr.value;
+                        styleName = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 70:
+                        style.standardFlag = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 40:
+                        style.fixedTextHeight = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 41:
+                        style.widthFactor = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 50:
+                        style.obliqueAngle = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 71:
+                        style.textGenerationFlag = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 42:
+                        style.lastHeight = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 3:
+                        style.font = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 4:
+                        style.bigFont = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 1071:
+                        style.extendedFont = curr.value;
+                        curr = scanner.next();
+                        break;
+                    case 0:
+                        if (curr.value === 'STYLE') {
+                            log.debug('}');
+                            styles[styleName] = style;
+                            log.debug('Style {');
+                            style = {};
+                            styleName = undefined;
+                            curr = scanner.next();
+                        }
+                        break;
+                    default:
+                        logUnhandledGroup(curr);
+                        curr = scanner.next();
+                        break;
+                }
+            }
+            log.debug('}');
+            styles[styleName] = style;
+            return styles;
+        };
+        const tableDefinitions = {
+            VPORT: {
+                tableRecordsProperty: 'viewPorts',
+                tableName: 'viewPort',
+                dxfSymbolName: 'VPORT',
+                parseTableRecords: parseViewPortRecords,
+            },
+            LTYPE: {
+                tableRecordsProperty: 'lineTypes',
+                tableName: 'lineType',
+                dxfSymbolName: 'LTYPE',
+                parseTableRecords: parseLineTypes,
+            },
+            LAYER: {
+                tableRecordsProperty: 'layers',
+                tableName: 'layer',
+                dxfSymbolName: 'LAYER',
+                parseTableRecords: parseLayers,
+            },
+            DIMSTYLE: {
+                tableRecordsProperty: 'dimStyles',
+                tableName: 'dimstyle',
+                dxfSymbolName: 'DIMSTYLE',
+                parseTableRecords: parseDimStyles,
+            },
+            STYLE: {
+                tableRecordsProperty: 'styles',
+                tableName: 'style',
+                dxfSymbolName: 'STYLE',
+                parseTableRecords: parseStyles,
+            },
+        };
+        /**
+         * Is called after the parser first reads the 0:ENTITIES group. The scanner
+         * should be on the start of the first entity already.
+         * @return the resulting entities
+         */
+        const parseEntities = (forBlock) => {
+            const entities = [];
+            const endingOnValue = forBlock ? 'ENDBLK' : 'ENDSEC';
+            if (!forBlock) {
+                curr = scanner.next();
+            }
+            while (true) {
+                if (curr.code === 0) {
+                    if (curr.value === endingOnValue) {
+                        break;
+                    }
+                    const handler = self._entityHandlers[curr.value];
+                    if (handler != null) {
+                        log.debug(curr.value + ' {');
+                        const entity = handler.parseEntity(scanner, curr);
+                        curr = scanner.lastReadGroup;
+                        log.debug('}');
+                        ensureHandle(entity);
+                        entities.push(entity);
+                    }
+                    else {
+                        log.warn('Unhandled entity ' + curr.value);
+                        curr = scanner.next();
+                        continue;
+                    }
+                }
+                else {
+                    // ignored lines from unsupported entity
+                    curr = scanner.next();
+                }
+            }
+            if (endingOnValue == 'ENDSEC') {
+                curr = scanner.next(); // swallow up ENDSEC, but not ENDBLK
+            }
+            return entities;
+        };
+        /**
+         * Parses a 2D or 3D point, returning it as an object with x, y, and
+         * (sometimes) z property if it is 3D. It is assumed the current group
+         * is x of the point being read in, and scanner.next() will return the
+         * y. The parser will determine if there is a z point automatically.
+         * @return The 2D or 3D point as an object with x, y[, z]
+         */
+        const parsePoint = () => {
+            const point = {};
+            let code = curr.code;
+            point.x = curr.value;
+            code += 10;
+            curr = scanner.next();
+            if (curr.code != code)
+                throw new Error('Expected code for point value to be ' + code +
+                    ' but got ' + curr.code + '.');
+            point.y = curr.value;
+            code += 10;
+            curr = scanner.next();
+            if (curr.code != code) {
+                scanner.rewind();
+                return point;
+            }
+            point.z = curr.value;
+            return point;
+        };
+        const ensureHandle = (entity) => {
+            if (!entity) {
+                throw new TypeError('entity cannot be undefined or null');
+            }
+            if (!entity.handle) {
+                entity.handle = lastHandle++;
+            }
+        };
+        parseAll();
+        return dxf;
+    }
+}
+function logUnhandledGroup(curr) {
+    log.debug('unhandled group ' + debugCode(curr));
+}
+function debugCode(curr) {
+    return curr.code + ':' + curr.value;
+}
+/**
+ * Returns the truecolor value of the given AutoCad color index value
+ * @return truecolor value as a number
+ */
+function getAcadColor(index) {
+    return AUTO_CAD_COLOR_INDEX[index];
+}
+/* Notes */
+// Code 6 of an entity indicates inheritance of properties (eg. color).
+//   BYBLOCK means inherits from block
+//   BYLAYER (default) mean inherits from layer