@jscad/dxf-deserializer 2.3.27 → 3.0.1-alpha.0

package/{autocad.js → src/autocad.js}

@@ -1,11 +1,5 @@
 /*
 AutoCAD Constants
-
-## License
-
-Copyright (c) 2017 Z3 Development https://github.com/z3dev
-
-All code released under MIT license
 */
 
 //
@@ -35,12 +29,12 @@ const dxfTLA = [
 
 const dxfMap = new Map(dxfTLA)
 
-const getTLA = (group) => dxfMap.get(group)
+export const getTLA = (group) => dxfMap.get(group)
 
 /*
  * AutoCAD Drawing Units
  */
-const drawingUnits = [
+export const drawingUnits = [
   [0, 'none'],
   [1, 'inches'],
   [2, 'feet'],
@@ -64,12 +58,5 @@ const drawingUnits = [
   [20, 'parsecs']
 ]
 
-const BYBLOCK = 0
-const BYLAYER = 256
-
-module.exports = {
-  drawingUnits,
-  BYBLOCK,
-  BYLAYER,
-  getTLA
-}
+export const BYBLOCK = 0
+export const BYLAYER = 256

package/{colorindex2014.js → src/colorindex2014.js}

@@ -2,7 +2,7 @@
  * AutoCAD 2014 Color Index (1-255) as RGB + ALPHA colors
  */
 
-const colorIndex = [
+export const colorIndex = [
   [0, 0, 0, 255], // index 0, added for easy maintenance
   // 1
   [255, 0, 0, 255],
@@ -286,5 +286,3 @@ const colorIndex = [
   [224, 224, 224, 255],
   [0, 0, 0, 255]
 ]
-
-module.exports = colorIndex

package/{colorindex2017.js → src/colorindex2017.js}

@@ -2,7 +2,7 @@
  * AutoCAD 2017 2018 Color Index (1-255) as RGB + ALPHA colors
  */
 
-const colorIndex = [
+export const colorIndex = [
   [0, 0, 0, 255], // index 0, added for easy maintenance
   // 1
   [255, 0, 0, 255],
@@ -286,5 +286,3 @@ const colorIndex = [
   [204, 204, 204, 255],
   [255, 255, 255, 255]
 ]
-
-module.exports = colorIndex

package/{helpers.js → src/helpers.js}

@@ -1,18 +1,9 @@
-/*
-## License
-
-Copyright (c) 2017-2019 Z3 Development https://github.com/z3dev
-
-All code released under MIT license
-
-*/
-
-const { BYBLOCK, BYLAYER } = require('./autocad')
+import { BYBLOCK, BYLAYER } from './autocad.js'
 
 //
 // find the layer referenced by the given object
 //
-const findLayer = (obj, layers) => {
+export const findLayer = (obj, layers) => {
   const lname = obj.lnam || '0'
   for (const layer of layers) {
     if (layer.name === lname) {
@@ -26,7 +17,7 @@ const findLayer = (obj, layers) => {
 // get the color number of the object, possibly looking at layer
 // returns -1 if a color number was not found
 //
-const getColorNumber = (obj, layers) => {
+export const getColorNumber = (obj, layers) => {
   let cn = obj.cnmb || -1
   if (cn === BYLAYER) {
     // use the color number from the layer
@@ -50,7 +41,7 @@ const mod = (num, mod) => {
 //
 // instantiate color using the given index into the given color index
 // Note: 0 > index <= length of colorindex
-const getColor = (index, colorindex) => {
+export const getColor = (index, colorindex) => {
   if (index < 1) { return null }
 
   index = mod(index, colorindex.length)
@@ -58,9 +49,3 @@ const getColor = (index, colorindex) => {
   const rgba = [color[0] / 255, color[1] / 255, color[2] / 255, color[3] / 255]
   return rgba
 }
-
-module.exports = {
-  findLayer,
-  getColor,
-  getColorNumber
-}

package/{index.js → src/index.js}

@@ -1,21 +1,12 @@
-/*
-## License
+import { ensureString } from '@jscad/io-utils'
 
-Copyright (c) 2017 Z3 Development https://github.com/z3dev
+import { BYLAYER, getTLA } from './autocad.js'
+import { colorIndex } from './colorindex2017.js'
+import { DxfReader } from './DxfReader.js'
+import { instantiateAsciiDxf } from './instantiate.js'
+import { translateAsciiDxf } from './translate.js'
 
-All code released under MIT license
-
-*/
-
-const { ensureString } = require('@jscad/io-utils')
-
-const version = require('./package.json').version
-
-const { BYLAYER, getTLA } = require('./autocad')
-const colorIndex = require('./colorindex2017')
-const dxf = require('./DxfReader')
-const { instantiateAsciiDxf } = require('./instantiate')
-const translateAsciiDxf = require('./translate')
+const version = '[VI]{version}[/VI]' // version is injected by rollup
 
 // //////////////////////////////////////////
 //
@@ -278,7 +269,7 @@ const handleXcoord = (reader, group, value) => {
   const obj = reader.objstack.pop()
   if ('type' in obj) {
     if (obj.type === 'lwpolyline') {
-      // special handling to build a list of vertices
+    // special handling to build a list of vertices
       if (obj.pptxs === undefined) {
         obj.pptxs = []
         obj.bulgs = []
@@ -287,7 +278,7 @@ const handleXcoord = (reader, group, value) => {
       obj.bulgs.push(0)
     } else {
       if (obj.type === 'mesh') {
-        // special handling to build a list of vertices
+      // special handling to build a list of vertices
         if (obj.pptxs === undefined) {
           obj.pptxs = []
         }
@@ -310,7 +301,7 @@ const handleYcoord = (reader, group, value) => {
   const obj = reader.objstack.pop()
   if ('type' in obj) {
     if (obj.type === 'lwpolyline' || obj.type === 'mesh') {
-      // special handling to build a list of vertices
+    // special handling to build a list of vertices
       if (obj.pptys === undefined) {
         obj.pptys = []
       }
@@ -332,7 +323,7 @@ const handleZcoord = (reader, group, value) => {
   const obj = reader.objstack.pop()
   if ('type' in obj) {
     if (obj.type === 'mesh') {
-      // special handling to build a list of vertices
+    // special handling to build a list of vertices
       if (obj.pptzs === undefined) {
         obj.pptzs = []
       }
@@ -354,7 +345,7 @@ const handleBulge = (reader, group, value) => {
   const obj = reader.objstack.pop()
   if ('type' in obj) {
     if (obj.type === 'lwpolyline') {
-      // special handling to build a list of vertices
+    // special handling to build a list of vertices
       const bulgs = obj.bulgs
       if (bulgs !== undefined) {
         const pptxs = obj.pptxs
@@ -379,7 +370,7 @@ const handleLen = (reader, group, value) => {
   const obj = reader.objstack.pop()
   if ('type' in obj) {
     if (obj.type === 'mesh') {
-      // mesh has an order of lengths
+    // mesh has an order of lengths
       const state = obj.state
       // console.log('mesh len: '+group+','+value+','+state)
       switch (group) {
@@ -493,64 +484,65 @@ const handleName = (reader, group, value) => {
 //
 const createReader = (src, options) => {
   // create a reader for the DXF
-  const reader = dxf.reader(options)
+  const dxfreader = new DxfReader(options)
 
   // setup event handling from the reader
-  reader.on('error', handleError)
-  reader.on('start', handleStart)
-  reader.on('end', handleEnd)
+  dxfreader.on('error', handleError)
+  dxfreader.on('start', handleStart)
+  dxfreader.on('end', handleEnd)
 
   // setup group handling
-  reader.absorb(0, handleEntity)
-  reader.absorb(1, handleString)
-  reader.absorb(2, handleName)
-  reader.absorb(3, handleName)
-  reader.absorb(6, handleString)
-  reader.absorb(7, handleString)
-  reader.absorb(8, handleString)
-  reader.absorb(9, handleVariable)
-  reader.absorb(10, handleXcoord)
-  reader.absorb(11, handleDouble)
-  reader.absorb(12, handleDouble)
-  reader.absorb(13, handleDouble)
-  reader.absorb(20, handleYcoord)
-  reader.absorb(21, handleDouble)
-  reader.absorb(22, handleDouble)
-  reader.absorb(23, handleDouble)
-  reader.absorb(30, handleZcoord)
-  reader.absorb(31, handleDouble)
-  reader.absorb(32, handleDouble)
-  reader.absorb(33, handleDouble)
-  reader.absorb(39, handleDouble)
-  reader.absorb(40, handleDouble)
-  reader.absorb(41, handleDouble)
-  reader.absorb(42, handleBulge)
-  reader.absorb(50, handleDouble)
-  reader.absorb(51, handleDouble)
-  reader.absorb(62, handleInt)
-  reader.absorb(70, handleInt)
-  reader.absorb(71, handleInt)
-  reader.absorb(72, handleInt)
-  reader.absorb(73, handleInt)
-  reader.absorb(74, handleInt)
-  reader.absorb(75, handleInt)
-  reader.absorb(90, handleValue)
-  reader.absorb(91, handleLen) // MESH
-  reader.absorb(92, handleLen) // MESH
-  reader.absorb(93, handleLen) // MESH
-  reader.absorb(94, handleLen) // MESH
-  reader.absorb(95, handleLen) // MESH
-  reader.absorb(210, handleInt)
-  reader.absorb(220, handleInt)
-  reader.absorb(230, handleInt)
+  dxfreader.absorb(0, handleEntity)
+  dxfreader.absorb(1, handleString)
+  dxfreader.absorb(2, handleName)
+  dxfreader.absorb(3, handleName)
+  dxfreader.absorb(6, handleString)
+  dxfreader.absorb(7, handleString)
+  dxfreader.absorb(8, handleString)
+  dxfreader.absorb(9, handleVariable)
+  dxfreader.absorb(10, handleXcoord)
+  dxfreader.absorb(11, handleDouble)
+  dxfreader.absorb(12, handleDouble)
+  dxfreader.absorb(13, handleDouble)
+  dxfreader.absorb(20, handleYcoord)
+  dxfreader.absorb(21, handleDouble)
+  dxfreader.absorb(22, handleDouble)
+  dxfreader.absorb(23, handleDouble)
+  dxfreader.absorb(30, handleZcoord)
+  dxfreader.absorb(31, handleDouble)
+  dxfreader.absorb(32, handleDouble)
+  dxfreader.absorb(33, handleDouble)
+  dxfreader.absorb(39, handleDouble)
+  dxfreader.absorb(40, handleDouble)
+  dxfreader.absorb(41, handleDouble)
+  dxfreader.absorb(42, handleBulge)
+  dxfreader.absorb(50, handleDouble)
+  dxfreader.absorb(51, handleDouble)
+  dxfreader.absorb(62, handleInt)
+  dxfreader.absorb(70, handleInt)
+  dxfreader.absorb(71, handleInt)
+  dxfreader.absorb(72, handleInt)
+  dxfreader.absorb(73, handleInt)
+  dxfreader.absorb(74, handleInt)
+  dxfreader.absorb(75, handleInt)
+  dxfreader.absorb(90, handleValue)
+  dxfreader.absorb(91, handleLen) // MESH
+  dxfreader.absorb(92, handleLen) // MESH
+  dxfreader.absorb(93, handleLen) // MESH
+  dxfreader.absorb(94, handleLen) // MESH
+  dxfreader.absorb(95, handleLen) // MESH
+  dxfreader.absorb(210, handleInt)
+  dxfreader.absorb(220, handleInt)
+  dxfreader.absorb(230, handleInt)
 
   // initial state
-  reader.objstack = []
-  reader.objstack.push({ type: 'dxf' })
+  dxfreader.objstack = []
+  dxfreader.objstack.push({ type: 'dxf' })
 
   // start the reader
-  reader.write(src).close()
-  return reader
+  dxfreader.write(src)
+  dxfreader.close()
+  return dxfreader
 }
 
 //
@@ -604,13 +596,13 @@ const deserialize = (options, src) => {
   }
   options = Object.assign({}, defaults, options)
 
-  src = ensureString(src)
+  src = ensureString(src);
   return options.output === 'script' ? translate(src, options) : instantiate(src, options)
 }
 
-const extension = 'dxf'
+const mimeType = 'image/vnd.dxf'
 
-module.exports = {
-  deserialize,
-  extension
+export {
+  mimeType,
+  deserialize
 }

package/{instantiate.js → src/instantiate.js}

@@ -1,38 +1,31 @@
-/*
-## License
+import { arc, circle, ellipse, geom2, geom3, mat4, line, path2, poly3, vec2, vec3 } from '@jscad/modeling'
 
-Copyright (c) 2017 Z3 Development https://github.com/z3dev
+import { getColor, getColorNumber } from './helpers.js'
 
-All code released under MIT license
-
-*/
-const { geometries, maths, primitives } = require('@jscad/modeling')
 const EPS = 1e-5 // FIXME
 
-const { getColor, getColorNumber } = require('./helpers')
-
 //
 // instantiate the given object (3dface) as a polygon
 //
-const instantiatePolygon = (obj, layers, options) => {
+export const instantiatePolygon = (obj, layers, options) => {
   const vertices = []
   // FIXME: should check global variable to instantiate in the proper orientation
-  vertices.push(maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz))
-  vertices.push(maths.vec3.fromValues(obj.sptx, obj.spty, obj.sptz))
-  vertices.push(maths.vec3.fromValues(obj.tptx, obj.tpty, obj.tptz))
+  vertices.push(vec3.fromValues(obj.pptx, obj.ppty, obj.pptz))
+  vertices.push(vec3.fromValues(obj.sptx, obj.spty, obj.sptz))
+  vertices.push(vec3.fromValues(obj.tptx, obj.tpty, obj.tptz))
   if (obj.fptx) {
     let pushit = false
     if (obj.tptx !== obj.fptx) { pushit = true }
     if (obj.tpty !== obj.fpty) { pushit = true }
     if (obj.tptz !== obj.fptz) { pushit = true }
     if (pushit) {
-      vertices.push(maths.vec3.fromValues(obj.fptx, obj.fpty, obj.fptz))
+      vertices.push(vec3.fromValues(obj.fptx, obj.fpty, obj.fptz))
     }
   }
   const cn = getColorNumber(obj, layers)
   const color = getColor(cn, options.colorindex)
 
-  const polygon = geometries.poly3.create(vertices)
+  const polygon = poly3.create(vertices)
   if (color) polygon.color = color
   return polygon
 }
@@ -43,21 +36,21 @@ const instantiatePolygon = (obj, layers, options) => {
 const instantiateLine = (obj, layers, options) => {
   // console.log('***** instantiateLine',obj)
   if (obj.pptz === obj.sptz && obj.pptz === 0) {
-    const p1 = maths.vec2.fromValues(obj.pptx, obj.ppty)
-    const p2 = maths.vec2.fromValues(obj.sptx, obj.spty)
-    return primitives.line([p1, p2])
+    const p1 = vec2.fromValues(obj.pptx, obj.ppty)
+    const p2 = vec2.fromValues(obj.sptx, obj.spty)
+    return line([p1, p2])
   }
 
-  const p1 = maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
-  const p2 = maths.vec3.fromValues(obj.sptx, obj.spty, obj.sptz)
+  const p1 = vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
+  const p2 = vec3.fromValues(obj.sptx, obj.spty, obj.sptz)
   // FIXME what should this really create?
-  return primitives.line([p1, p2])
+  return line([p1, p2])
 }
 
 //
 // instantiate the give object as 2D Vector or 3D Vector wrapped as an object
 //
-const instantiateVector = (obj) => {
+export const instantiateVector = (obj) => {
   const d3line = parseInt('00000000000100000', 2)
   const d3mesh = parseInt('00000000001000000', 2)
   const d3face = parseInt('00000000010000000', 2)
@@ -65,20 +58,20 @@ const instantiateVector = (obj) => {
   const flags = obj.lflg
   const vtype = {}
   if ((flags & d3line) === d3line) {
-    vtype.vec = maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
+    vtype.vec = vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
   } else
   if ((flags & d3mesh) === d3mesh) {
-    vtype.vec = maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
+    vtype.vec = vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
   } else
   if ((flags & d3face) === d3face) {
-    vtype.vec = maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
+    vtype.vec = vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
     // pass on face indexes
     vtype.fvia = obj.fvia
     vtype.fvib = obj.fvib
     vtype.fvic = obj.fvic
     vtype.fvid = obj.fvid
   } else {
-    vtype.vec = maths.vec2.fromValues(obj.pptx, obj.ppty)
+    vtype.vec = vec2.fromValues(obj.pptx, obj.ppty)
     vtype.bulg = obj.bulg // for rendering curved sections
   }
   return vtype
@@ -90,20 +83,20 @@ const instantiateVector = (obj) => {
 const addSection = (path, x1, y1, bulg) => {
   if (bulg === 0) {
   // add straight line to the end of the path
-    path = geometries.path2.appendPoints([[x1, y1]], path)
+    path = path2.appendPoints([[x1, y1]], path)
   } else {
   // add arc to the end of the path
-    const points = geometries.path2.toPoints(path)
+    const points = path2.toPoints(path)
     const prev = points[points.length - 1]
-    const curr = maths.vec2.fromValues(x1, y1)
-    const u = maths.vec2.distance(prev, curr)
+    const curr = vec2.fromValues(x1, y1)
+    const u = vec2.distance(prev, curr)
     const r = u * ((1 + Math.pow(bulg, 2)) / (4 * bulg))
     const clockwise = (bulg < 0)
     const large = false // FIXME how to determine?
     const d = Math.atan(bulg) * 4
     // FIXME; how to determine resolution
     const res = 16
-    path = geometries.path2.appendArc({ endpoint: [x1, y1], radius: [r, r], xaxisrotation: d, clockwise: clockwise, large: large, segments: res }, path)
+    path = path2.appendArc({ endpoint: [x1, y1], radius: [r, r], xaxisrotation: d, clockwise: clockwise, large: large, segments: res }, path)
   }
   return path
 }
@@ -123,7 +116,7 @@ const instantiatePath2D = (obj, layers, options) => {
   const flags = obj.lflg
 
   // conversion
-  let path = geometries.path2.create()
+  let path = path2.create()
   const isclosed = ((flags & closed) === closed)
   if (vlen === pptxs.length && vlen === pptys.length && vlen === bulgs.length) {
     pptxs.forEach((item, index, array) => {
@@ -140,7 +133,7 @@ const instantiatePath2D = (obj, layers, options) => {
   if (isclosed && (!path.isClosed)) {
   // apply the last section between last and first points
     path = addSection(path, pptxs[0], pptys[0], bulgs[vlen - 1])
-    path = geometries.path2.close(path)
+    path = path2.close(path)
     // FIXME add optional to create 2D geometry from the path
   }
   return path
@@ -166,10 +159,10 @@ const instantiateArc = (obj, layers, options) => {
   // conversion
   if (lthk === 0.0) {
     // convert to 2D object
-    return primitives.arc({ center: [pptx, ppty], radius: swid, startAngle: ang0, endAngle: ang1, segments: res })
+    return arc({ center: [pptx, ppty], radius: swid, startAngle: ang0, endAngle: ang1, segments: res })
   }
   // FIXME how to represent 3D arc?
-  return primitives.arc({ center: [pptx, ppty], radius: swid, startAngle: ang0, endAngle: ang1, segments: res })
+  return arc({ center: [pptx, ppty], radius: swid, startAngle: ang0, endAngle: ang1, segments: res })
 }
 
 //
@@ -191,12 +184,12 @@ const instantiateCircle = (obj, layers, options) => {
 
   // convert to 2D object
   if (lthk === 0.0) {
-    const cag = primitives.circle({ center: [pptx, ppty], radius: swid, segments: res })
+    const cag = circle({ center: [pptx, ppty], radius: swid, segments: res })
     if (color) cag.color = color
     return cag
   }
   // convert to 3D object
-  const cag = primitives.circle({ center: [pptx, ppty], radius: swid, segments: res })
+  const cag = circle({ center: [pptx, ppty], radius: swid, segments: res })
   const csg = cag.extrude({ offset: [0, 0, lthk] })
   // FIXME need to use 210/220/230 for direction of extrusion
   if (color) csg.color = color
@@ -220,19 +213,19 @@ const instantiateEllipse = (obj, layers, options) => {
 
   // convert to 2D object
   if (pptz === 0.0 && sptz === 0.0) {
-    const center = maths.vec2.fromValues(0, 0)
-    const mjaxis = maths.vec2.fromValues(sptx, spty)
-    const rx = maths.vec2.distance(center, mjaxis)
+    const center = vec2.fromValues(0, 0)
+    const mjaxis = vec2.fromValues(sptx, spty)
+    const rx = vec2.distance(center, mjaxis)
     const ry = rx * swid
     let angle = Math.atan2(spty, sptx) * 180 / Math.PI
     if (angle < EPS) angle = 0
     angle = angle * 0.017453292519943295 // radians
 
     // FIXME add start and end angle when supported
-    const cag = primitives.ellipse({ center: [0, 0], radius: [rx, ry], segments: res })
-    const matrix = maths.mat4.fromZRotation(maths.mat4.create(), angle)
-    maths.mat4.multiply(matrix, matrix, maths.mat4.fromTranslation(maths.mat4.create(), [pptx, ppty, 0]))
-    return geometries.geom2.transform(matrix, cag)
+    const cag = ellipse({ center: [0, 0], radius: [rx, ry], segments: res })
+    const matrix = mat4.fromZRotation(mat4.create(), angle)
+    mat4.multiply(matrix, matrix, mat4.fromTranslation(mat4.create(), [pptx, ppty, 0]))
+    return geom2.transform(matrix, cag)
   }
   // convert to 3D object
 }
@@ -297,7 +290,7 @@ const instantiateMesh = (obj, layers, options) => {
         let vi = 0
         while (vi < face.length) {
           const pi = face[vi]
-          const vertex = maths.vec3.clone(points[pi])
+          const vertex = vec3.clone(points[pi])
           vertices.push(vertex)
           vi++
         }
@@ -306,7 +299,7 @@ const instantiateMesh = (obj, layers, options) => {
         }
         // FIXME how to correct bad normals?
 
-        const poly = geometries.poly3.create(vertices)
+        const poly = poly3.create(vertices)
         if (color) poly.color = color
         polygons.push(poly)
 
@@ -318,7 +311,7 @@ const instantiateMesh = (obj, layers, options) => {
   } else {
     // invalid vlen
   }
-  return geometries.geom3.create(polygons)
+  return geom3.create(polygons)
 }
 
 // works for both POLYLINE
@@ -336,16 +329,16 @@ const getPolyType = (obj) => {
     ptype = null // FIXME what to do?
   } else
   if ((flags & d3mesh) === d3mesh) {
-    ptype = geometries.geom3.create()
+    ptype = geom3.create()
     ptype.closedM = ((flags & closedM) === closedM)
     ptype.closedN = ((flags & closedN) === closedN)
   } else
   if ((flags & d3face) === d3face) {
-    ptype = geometries.geom3.create()
+    ptype = geom3.create()
     ptype.closedM = ((flags & closedM) === closedM)
     ptype.closedN = ((flags & closedN) === closedN)
   } else {
-    ptype = geometries.path2.create()
+    ptype = path2.create()
     ptype.closedM = ((flags & closedM) === closedM)
   }
   if ('cnmb' in obj) { ptype.cnmb = obj.cnmb }
@@ -358,23 +351,23 @@ const getPolyType = (obj) => {
 // - a series of vertex => vectors => 2D geometry
 //
 const completeCurrent = (objects, baseobj, polygons, vectors, options) => {
-  if (geometries.path2.isA(baseobj)) {
+  if (path2.isA(baseobj)) {
     // console.log('##### completing 2D geometry')
     const points = vectors.map((vector) => vector.vec)
     // FIXME add color support
-    objects.push(geometries.path2.fromPoints({ closed: baseobj.closed }, points))
+    objects.push(path2.fromPoints({ closed: baseobj.closed }, points))
   }
-  if (geometries.geom3.isA(baseobj)) {
+  if (geom3.isA(baseobj)) {
     // console.log('##### completing 3D geometry')
     // FIXME add color support
-    objects.push(geometries.geom3.create(polygons))
+    objects.push(geom3.create(polygons))
   }
   return null
 }
 
-const instantiateAsciiDxf = (reader, options) => {
+export const instantiateAsciiDxf = (reader, options) => {
   // console.log('**************************************************')
-  // console.log(JSON.stringify(reader.objstack));
+  // console.log(JSON.stringify(reader.objstack))
   // console.log('**************************************************')
 
   const layers = [] // list of layers with various information like color
@@ -391,7 +384,7 @@ const instantiateAsciiDxf = (reader, options) => {
       // console.log('##### skip')
       continue
     }
-    // console.log(JSON.stringify(obj));
+    // console.log(JSON.stringify(obj))
 
     switch (obj.type) {
     // control objects
@@ -412,7 +405,7 @@ const instantiateAsciiDxf = (reader, options) => {
         p = instantiatePolygon(obj, layers, options)
         if (current === null) {
           // console.log('##### start of 3dfaces')
-          current = geometries.geom3.create()
+          current = geom3.create()
         }
         break
       case 'mesh':
@@ -470,7 +463,7 @@ const instantiateAsciiDxf = (reader, options) => {
         break
     }
     // accumlate polygons if necessary
-    if (geometries.poly3.isA(p)) {
+    if (poly3.isA(p)) {
       polygons.push(p)
     }
     // accumlate vectors if necessary
@@ -488,15 +481,9 @@ const instantiateAsciiDxf = (reader, options) => {
   // console.log('**************************************************')
   // objects.forEach(
   //   (e) => {
-  //     console.log(JSON.stringify(e));
+  //     console.log(JSON.stringify(e))
   //   }
-  // );
+  // )
   // console.log('**************************************************')
   return objects
 }
-
-module.exports = {
-  instantiatePolygon,
-  instantiateVector,
-  instantiateAsciiDxf
-}