@jscad/svg-deserializer 2.2.4 → 2.4.2

package/CHANGELOG.md

@@ -3,6 +3,49 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.4.2](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/svg-deserializer@2.4.1...@jscad/svg-deserializer@2.4.2) (2021-10-17)
+
+**Note:** Version bump only for package @jscad/svg-deserializer
+
+
+
+
+
+## [2.4.1](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/svg-deserializer@2.4.0...@jscad/svg-deserializer@2.4.1) (2021-10-04)
+
+**Note:** Version bump only for package @jscad/svg-deserializer
+
+
+
+
+
+# [2.4.0](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/svg-deserializer@2.3.0...@jscad/svg-deserializer@2.4.0) (2021-09-27)
+
+
+### Bug Fixes
+
+* **modeling:** corrected concat to ignore duplicate points ([#913](https://github.com/jscad/OpenJSCAD.org/issues/913))corrected appendArc to maintain last point ([3eea3ef](https://github.com/jscad/OpenJSCAD.org/commit/3eea3efed3b3d4bacb49c1ee4691bfc159b08261))
+
+
+### Features
+
+* **svg-deserializer:** reworked to use saxes library, and standard module layout ([56f5725](https://github.com/jscad/OpenJSCAD.org/commit/56f572518c85d767ac680aa2da1af46c4847e63c))
+
+
+
+
+
+# [2.3.0](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/svg-deserializer@2.2.4...@jscad/svg-deserializer@2.3.0) (2021-09-09)
+
+
+### Features
+
+* **svg-deserializer:** added pathSelfClosed option to control construction of overlapping paths ([043f59d](https://github.com/jscad/OpenJSCAD.org/commit/043f59d928fcf397b0bb23e744e35d7eda5be626))
+
+
+
+
+
 ## [2.2.4](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/svg-deserializer@2.2.3...@jscad/svg-deserializer@2.2.4) (2021-06-20)
 
 **Note:** Version bump only for package @jscad/svg-deserializer

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@jscad/svg-deserializer",
-  "version": "2.2.4",
+  "version": "2.4.2",
   "description": "SVG Deserializer for JSCAD",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
-  "main": "index.js",
+  "main": "src/index.js",
   "scripts": {
     "coverage": "nyc --all --reporter=html --reporter=text npm test",
     "test": "ava --verbose --timeout 2m './tests/*.test.js'"
@@ -32,12 +32,12 @@
   "license": "MIT",
   "dependencies": {
     "@jscad/array-utils": "2.1.0",
-    "@jscad/modeling": "2.5.0",
-    "sax": "1.2.4"
+    "@jscad/modeling": "2.6.0",
+    "saxes": "5.0.1"
   },
   "devDependencies": {
     "ava": "3.15.0",
     "nyc": "15.1.0"
   },
-  "gitHead": "18d1d0b53cf676c6349fa24be2253fd7c21e676b"
+  "gitHead": "3d1d02f2863c65fd95406c7098c09297b3be1c10"
 }

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

@@ -124,8 +124,8 @@ const cagColor = (value) => {
 }
 
 const cssStyle = (element, name) => {
-  if ('STYLE' in element) {
-    const list = element.STYLE + ';'
+  if ('style' in element) {
+    const list = element.style + ';'
     const pat = name + '\\s*:\\s*(\\S+);'
     const exp = new RegExp(pat, 'i')
     let v = exp.exec(list)

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

@@ -10,12 +10,12 @@ have been very kindly sponsored by [Copenhagen Fabrication / Stykka](https://www
 All code released under MIT license
 */
 
-const sax = require('sax')
+const saxes = require('saxes')
 
 const { colors, transforms } = require('@jscad/modeling')
 const { toArray } = require('@jscad/array-utils')
 
-const version = require('./package.json').version
+const version = require('../package.json').version
 
 const { cagLengthX, cagLengthY, svgColorForTarget } = require('./helpers')
 const { svgSvg, svgRect, svgCircle, svgGroup, svgLine, svgPath, svgEllipse, svgPolygon, svgPolyline, svgUse } = require('./svgElementHelpers')
@@ -23,24 +23,26 @@ const shapesMapGeometry = require('./shapesMapGeometry')
 const shapesMapJscad = require('./shapesMapJscad')
 
 /**
- * Deserializer of STL data to JSCAD geometries.
- * @module io/stl-deserializer
+ * Deserializer of SVG source data to JSCAD geometries.
+ * @module io/svg-deserializer
  * @example
- * const { deserializer, extension } = require('@jscad/stl-deserializer')
+ * const { deserializer, extension } = require('@jscad/svg-deserializer')
  */
 
 /**
- * Parse the given SVG data and return either a JSCAD script or a set of geometries
+ * Deserialize the given SVG source into either a script or an array of geometries
+ * @see {@link https://www.w3.org/TR/SVG/intro.html|SVG Specification}
  * @param {Object} options - options used during deserializing, REQUIRED
  * @param {boolean} [options.addMetadata=true] - toggle injection of metadata at the start of the script
  * @param {string} [options.filename='svg'] - filename of original SVG source
  * @param {string} [options.output='script'] - either 'script' or 'geometry' to set desired output
  * @param {float} [options.pxPmm] - custom pixels per mm unit
  * @param {integer} [options.segments] - number of segments for rounded shapes
- * @param {string} [options.target] - target 2D geometry; geom2 or path2
+ * @param {string} [options.target] - target 2D geometry; 'geom2' or 'path2'
  * @param {string} [options.version='0.0.0'] - version number to add to the metadata
- * @param {string} input - SVG data
- * @return {string|[object]} either a string (script) or a set of objects (geometry)
+ * @param {string} [options.pathSelfClosed='error'] - [error||trim||split] if path self-closes with one of commands without stop command right after
+ * @param {string} input - SVG source data
+ * @returns {(Array|String)} either an array of objects (geometry) or a string (script)
  * @alias module:io/svg-deserializer.deserialize
  */
 const deserialize = (options, input) => {
@@ -51,16 +53,17 @@ const deserialize = (options, input) => {
     pxPmm: require('./constants').pxPmm,
     segments: 32,
     target: 'path', // target - 'geom2' or 'path'
+    pathSelfClosed: 'error',
     version
   }
   options = Object.assign({}, defaults, options)
   return options.output === 'script' ? translate(input, options) : instantiate(input, options)
 }
 
-/**
+/*
  * Parse the given SVG source and return a set of geometries.
- * @param  {string} src svg data as text
- * @param  {object} options options (optional) anonymous object with:
+ * @param  {string} src - svg data as text
+ * @param  {object} options - options (optional) anonymous object with:
  *  pxPmm {number} pixels per milimeter for calcuations
  *  version: {string} version number to add to the metadata
  *  addMetadata: {boolean} flag to enable/disable injection of metadata (producer, date, source)
@@ -75,7 +78,7 @@ const instantiate = (src, options) => {
   // parse the SVG source
   createSvgParser(src, pxPmm)
   if (!svgObj) {
-    throw new Error('SVG parsing failed, no valid svg data retrieved')
+    throw new Error('SVG parsing failed, no valid SVG data retrieved')
   }
 
   options && options.statusCallback && options.statusCallback({ progress: 50 })
@@ -86,7 +89,7 @@ const instantiate = (src, options) => {
   return result
 }
 
-/**
+/*
  * Parse the given SVG source and return a JSCAD script
  * @param  {string} src svg data as text
  * @param  {object} options options (optional) anonymous object with:
@@ -104,7 +107,7 @@ const translate = (src, options) => {
   // parse the SVG source
   createSvgParser(src, pxPmm)
   if (!svgObj) {
-    throw new Error('SVG parsing failed, no valid svg data retrieved')
+    throw new Error('SVG parsing failed, no valid SVG data retrieved')
   }
 
   // convert the internal objects to JSCAD code
@@ -144,7 +147,7 @@ let svgUnitsPmm = [1, 1]
  * Convert the given group (of objects) into geometries
  */
 const objectify = (options, group) => {
-  const { target, segments } = options
+  const { target, segments, pathSelfClosed } = options
   const level = svgGroups.length
   // add this group to the heiarchy
   svgGroups.push(group)
@@ -164,7 +167,8 @@ const objectify = (options, group) => {
     level,
     target,
     svgGroups,
-    segments
+    segments,
+    pathSelfClosed
   }
   // apply base level attributes to all shapes
   for (i = 0; i < group.objects.length; i++) {
@@ -322,14 +326,17 @@ const codify = (options, group) => {
 
 const createSvgParser = (src, pxPmm) => {
   // create a parser for the XML
-  const parser = sax.parser(false, { trim: true, lowercase: false, position: true })
+  const parser = new saxes.SaxesParser()
   if (pxPmm !== undefined && pxPmm > parser.pxPmm) {
     parser.pxPmm = pxPmm
   }
   // extend the parser with functions
-  parser.onerror = (e) => console.log('error: line ' + e.line + ', column ' + e.column + ', bad character [' + e.c + ']')
+  parser.on('error', (e) => {
+    console.log(`ERROR: SVG file, line ${parser.line}, column ${parser.column}`)
+    console.log(e)
+  })
 
-  parser.onopentag = function (node) {
+  parser.on('opentag', (node) => {
     const objMap = {
       SVG: svgSvg,
       G: svgGroup,
@@ -345,10 +352,12 @@ const createSvgParser = (src, pxPmm) => {
       DESC: () => undefined, // ignored by design
       TITLE: () => undefined, // ignored by design
       STYLE: () => undefined, // ignored by design
-      undefined: () => console.log('Warning: Unsupported SVG element: ' + node.name)
+      undefined: () => console.log('WARNING: unsupported SVG element: ' + node.name)
     }
     node.attributes.position = [parser.line + 1, parser.column + 1]
-    const obj = objMap[node.name] ? objMap[node.name](node.attributes, { svgObjects, customPxPmm: pxPmm }) : undefined
+
+    const elementName = node.name.toUpperCase()
+    const obj = objMap[elementName] ? objMap[elementName](node.attributes, { svgObjects, customPxPmm: pxPmm }) : undefined
 
     // case 'SYMBOL':
     // this is just like an embedded SVG but does NOT render directly, only named
@@ -396,9 +405,9 @@ const createSvgParser = (src, pxPmm) => {
         }
       }
     }
-  }
+  })
 
-  parser.onclosetag = function (node) {
+  parser.on('closetag', (node) => {
     const popGroup = () => {
       if (svgInDefs === true) {
         return svgDefs.pop()
@@ -414,19 +423,19 @@ const createSvgParser = (src, pxPmm) => {
       G: popGroup,
       undefined: () => {}
     }
-    const obj = objMap[node] ? objMap[node]() : undefined
+    const elementName = node.name.toUpperCase()
+    const obj = objMap[elementName] ? objMap[elementName]() : undefined
 
     // check for completeness
     if (svgGroups.length === 0) {
       svgObj = obj
     }
-  }
+  })
 
-  // parser.onattribute = function (attr) {};
-  // parser.ontext = function (t) {};
+  parser.on('end', () => {
+    // console.log('SVG parsing completed')
+  })
 
-  parser.onend = function () {
-  }
   // start the parser
   parser.write(src).close()
   return parser

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

@@ -4,7 +4,7 @@ const { svg2cagX, svg2cagY, cagLengthX, cagLengthY, cagLengthP, reflect } = requ
 // const { cssPxUnit } = require('./constants')
 
 const shapesMapGeometry = (obj, objectify, params) => {
-  const { svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, target, segments } = params
+  const { svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, target, segments, pathSelfClosed } = params
 
   const types = {
     group: (obj) => objectify({ target, segments }, obj),
@@ -131,7 +131,7 @@ const shapesMapGeometry = (obj, objectify, params) => {
     },
 
     path: (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, segments) => {
-      const listofpaths = expandPath(obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, segments)
+      const listofpaths = expandPath(obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, segments, pathSelfClosed)
       // order is important
       const listofentries = Object.entries(listofpaths).sort((a, b) => a[0].localeCompare(b[0]))
       const shapes = listofentries.map((entry) => {
@@ -152,7 +152,12 @@ const shapesMapGeometry = (obj, objectify, params) => {
 
 module.exports = shapesMapGeometry
 
-const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, segments) => {
+const appendPoints = (points, geometry) => {
+  if (geometry) return geometries.path2.appendPoints(points, geometry)
+  return geometries.path2.fromPoints({ }, points)
+}
+
+const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, segments, pathSelfClosed) => {
   const paths = {}
   const on = 'path'
 
@@ -178,10 +183,18 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
   let qx = 0 // 2nd control point from previous Q command
   let qy = 0 // 2nd control point from previous Q command
 
+  const newPath = () => {
+    pi++
+    pathName = on + pi
+    pc = false
+  }
+  const ensurePath = () => {
+    if (!paths[pathName]) paths[pathName] = geometries.path2.fromPoints({}, [])
+  }
   for (let j = 0; j < obj.commands.length; j++) {
     const co = obj.commands[j]
     const pts = co.p
-    // console.log('postion: ['+cx+','+cy+'] before '+co.c);
+    let i = 0
     switch (co.c) {
       case 'm': // relative move to X,Y
         // special case, if at beginning of path then treat like absolute M
@@ -193,20 +206,18 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           // FIXME paths[pathName] =  paths[pathName]
         }
         // open a new path
-        if (pts.length >= 2) {
-          cx = cx + parseFloat(pts.shift())
-          cy = cy + parseFloat(pts.shift())
-          pi++
-          pathName = on + pi
-          pc = false
-          paths[pathName] = geometries.path2.fromPoints({ }, [[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]])
+        if (pts.length >= i + 2) {
+          cx = cx + parseFloat(pts[i++])
+          cy = cy + parseFloat(pts[i++])
+          newPath()
+          paths[pathName] = appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]])
           sx = cx; sy = cy
         }
         // optional implicit relative lineTo (cf SVG spec 8.3.2)
-        while (pts.length >= 2) {
-          cx = cx + parseFloat(pts.shift())
-          cy = cy + parseFloat(pts.shift())
-          paths[pathName] = geometries.path2.appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
+        while (pts.length >= i + 2) {
+          cx = cx + parseFloat(pts[i++])
+          cy = cy + parseFloat(pts[i++])
+          paths[pathName] = appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
         }
         break
       case 'M': // absolute move to X,Y
@@ -215,54 +226,55 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           // FIXME paths[pathName] = paths[pathName]
         }
         // open a new path
-        if (pts.length >= 2) {
-          cx = parseFloat(pts.shift())
-          cy = parseFloat(pts.shift())
-          pi++
-          pathName = on + pi
-          pc = false
-          paths[pathName] = geometries.path2.fromPoints({ }, [[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]])
+        if (pts.length >= i + 2) {
+          cx = parseFloat(pts[i++])
+          cy = parseFloat(pts[i++])
+          newPath()
+          paths[pathName] = appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]])
           sx = cx; sy = cy
         }
         // optional implicit absolute lineTo (cf SVG spec 8.3.2)
-        while (pts.length >= 2) {
-          cx = parseFloat(pts.shift())
-          cy = parseFloat(pts.shift())
-          paths[pathName] = geometries.path2.appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
+        while (pts.length >= i + 2) {
+          cx = parseFloat(pts[i++])
+          cy = parseFloat(pts[i++])
+          paths[pathName] = appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
         }
         break
       case 'a': // relative elliptical arc
-        while (pts.length >= 7) {
-          const rx = parseFloat(pts.shift())
-          const ry = parseFloat(pts.shift())
-          const ro = 0 - parseFloat(pts.shift()) * 0.017453292519943295 // radians
-          const lf = (pts.shift() === '1')
-          const sf = (pts.shift() === '1')
-          cx = cx + parseFloat(pts.shift())
-          cy = cy + parseFloat(pts.shift())
+        while (pts.length >= i + 7) {
+          const rx = parseFloat(pts[i++])
+          const ry = parseFloat(pts[i++])
+          const ro = 0 - parseFloat(pts[i++]) * 0.017453292519943295 // radians
+          const lf = (pts[i++] === '1')
+          const sf = (pts[i++] === '1')
+          cx = cx + parseFloat(pts[i++])
+          cy = cy + parseFloat(pts[i++])
+          ensurePath()
           paths[pathName] = geometries.path2.appendArc({ segments, endpoint: [svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)], radius: [svg2cagX(rx, svgUnitsPmm), svg2cagY(ry, svgUnitsPmm)], xaxisrotation: ro, clockwise: sf, large: lf }, paths[pathName])
         }
         break
       case 'A': // absolute elliptical arc
-        while (pts.length >= 7) {
-          const rx = parseFloat(pts.shift())
-          const ry = parseFloat(pts.shift())
-          const ro = 0 - parseFloat(pts.shift()) * 0.017453292519943295 // radians
-          const lf = (pts.shift() === '1')
-          const sf = (pts.shift() === '1')
-          cx = parseFloat(pts.shift())
-          cy = parseFloat(pts.shift())
+        while (pts.length >= i + 7) {
+          const rx = parseFloat(pts[i++])
+          const ry = parseFloat(pts[i++])
+          const ro = 0 - parseFloat(pts[i++]) * 0.017453292519943295 // radians
+          const lf = (pts[i++] === '1')
+          const sf = (pts[i++] === '1')
+          cx = parseFloat(pts[i++])
+          cy = parseFloat(pts[i++])
+          ensurePath()
           paths[pathName] = geometries.path2.appendArc({ segments, endpoint: [svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)], radius: [svg2cagX(rx, svgUnitsPmm), svg2cagY(ry, svgUnitsPmm)], xaxisrotation: ro, clockwise: sf, large: lf }, paths[pathName])
         }
         break
       case 'c': // relative cubic Bézier
-        while (pts.length >= 6) {
-          const x1 = cx + parseFloat(pts.shift())
-          const y1 = cy + parseFloat(pts.shift())
-          bx = cx + parseFloat(pts.shift())
-          by = cy + parseFloat(pts.shift())
-          cx = cx + parseFloat(pts.shift())
-          cy = cy + parseFloat(pts.shift())
+        while (pts.length >= i + 6) {
+          const x1 = cx + parseFloat(pts[i++])
+          const y1 = cy + parseFloat(pts[i++])
+          bx = cx + parseFloat(pts[i++])
+          by = cy + parseFloat(pts[i++])
+          cx = cx + parseFloat(pts[i++])
+          cy = cy + parseFloat(pts[i++])
+          ensurePath()
           paths[pathName] = geometries.path2.appendBezier({ segments, controlPoints: [[svg2cagX(x1, svgUnitsPmm), svg2cagY(y1, svgUnitsPmm)], [svg2cagX(bx, svgUnitsPmm), svg2cagY(by, svgUnitsPmm)], [svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]] }, paths[pathName])
           const rf = reflect(bx, by, cx, cy)
           bx = rf[0]
@@ -270,13 +282,14 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
         }
         break
       case 'C': // absolute cubic Bézier
-        while (pts.length >= 6) {
-          const x1 = parseFloat(pts.shift())
-          const y1 = parseFloat(pts.shift())
-          bx = parseFloat(pts.shift())
-          by = parseFloat(pts.shift())
-          cx = parseFloat(pts.shift())
-          cy = parseFloat(pts.shift())
+        while (pts.length >= i + 6) {
+          const x1 = parseFloat(pts[i++])
+          const y1 = parseFloat(pts[i++])
+          bx = parseFloat(pts[i++])
+          by = parseFloat(pts[i++])
+          cx = parseFloat(pts[i++])
+          cy = parseFloat(pts[i++])
+          ensurePath()
           paths[pathName] = geometries.path2.appendBezier({ segments, controlPoints: [[svg2cagX(x1, svgUnitsPmm), svg2cagY(y1, svgUnitsPmm)], [svg2cagX(bx, svgUnitsPmm), svg2cagY(by, svgUnitsPmm)], [svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]] }, paths[pathName])
           const rf = reflect(bx, by, cx, cy)
           bx = rf[0]
@@ -284,11 +297,12 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
         }
         break
       case 'q': // relative quadratic Bézier
-        while (pts.length >= 4) {
-          qx = cx + parseFloat(pts.shift())
-          qy = cy + parseFloat(pts.shift())
-          cx = cx + parseFloat(pts.shift())
-          cy = cy + parseFloat(pts.shift())
+        while (pts.length >= i + 4) {
+          qx = cx + parseFloat(pts[i++])
+          qy = cy + parseFloat(pts[i++])
+          cx = cx + parseFloat(pts[i++])
+          cy = cy + parseFloat(pts[i++])
+          ensurePath()
           paths[pathName] = geometries.path2.appendBezier({ segments, controlPoints: [[svg2cagX(qx, svgUnitsPmm), svg2cagY(qy, svgUnitsPmm)], [svg2cagX(qx, svgUnitsPmm), svg2cagY(qy, svgUnitsPmm)], [svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]] }, paths[pathName])
           const rf = reflect(qx, qy, cx, cy)
           qx = rf[0]
@@ -296,11 +310,12 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
         }
         break
       case 'Q': // absolute quadratic Bézier
-        while (pts.length >= 4) {
-          qx = parseFloat(pts.shift())
-          qy = parseFloat(pts.shift())
-          cx = parseFloat(pts.shift())
-          cy = parseFloat(pts.shift())
+        while (pts.length >= i + 4) {
+          qx = parseFloat(pts[i++])
+          qy = parseFloat(pts[i++])
+          cx = parseFloat(pts[i++])
+          cy = parseFloat(pts[i++])
+          ensurePath()
           paths[pathName] = geometries.path2.appendBezier({ segments, controlPoints: [[svg2cagX(qx, svgUnitsPmm), svg2cagY(qy, svgUnitsPmm)], [svg2cagX(qx, svgUnitsPmm), svg2cagY(qy, svgUnitsPmm)], [svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]] }, paths[pathName])
           const rf = reflect(qx, qy, cx, cy)
           qx = rf[0]
@@ -308,9 +323,10 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
         }
         break
       case 't': // relative quadratic Bézier shorthand
-        while (pts.length >= 2) {
-          cx = cx + parseFloat(pts.shift())
-          cy = cy + parseFloat(pts.shift())
+        while (pts.length >= i + 2) {
+          cx = cx + parseFloat(pts[i++])
+          cy = cy + parseFloat(pts[i++])
+          ensurePath()
           paths[pathName] = geometries.path2.appendBezier({ segments, controlPoints: [[svg2cagX(qx, svgUnitsPmm), svg2cagY(qy, svgUnitsPmm)], [svg2cagX(qx, svgUnitsPmm), svg2cagY(qy, svgUnitsPmm)], [cx, cy]] }, paths[pathName])
           const rf = reflect(qx, qy, cx, cy)
           qx = rf[0]
@@ -318,9 +334,10 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
         }
         break
       case 'T': // absolute quadratic Bézier shorthand
-        while (pts.length >= 2) {
-          cx = parseFloat(pts.shift())
-          cy = parseFloat(pts.shift())
+        while (pts.length >= i + 2) {
+          cx = parseFloat(pts[i++])
+          cy = parseFloat(pts[i++])
+          ensurePath()
           paths[pathName] = geometries.path2.appendBezier({ segments, controlPoints: [[svg2cagX(qx, svgUnitsPmm), svg2cagY(qy, svgUnitsPmm)], [svg2cagX(qx, svgUnitsPmm), svg2cagY(qy, svgUnitsPmm)], [svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]] }, paths[pathName])
           const rf = reflect(qx, qy, cx, cy)
           qx = rf[0]
@@ -328,13 +345,14 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
         }
         break
       case 's': // relative cubic Bézier shorthand
-        while (pts.length >= 4) {
+        while (pts.length >= i + 4) {
           const x1 = bx // reflection of 2nd control point from previous C
           const y1 = by // reflection of 2nd control point from previous C
-          bx = cx + parseFloat(pts.shift())
-          by = cy + parseFloat(pts.shift())
-          cx = cx + parseFloat(pts.shift())
-          cy = cy + parseFloat(pts.shift())
+          bx = cx + parseFloat(pts[i++])
+          by = cy + parseFloat(pts[i++])
+          cx = cx + parseFloat(pts[i++])
+          cy = cy + parseFloat(pts[i++])
+          ensurePath()
           paths[pathName] = geometries.path2.appendBezier({ segments, controlPoints: [[svg2cagX(x1, svgUnitsPmm), svg2cagY(y1, svgUnitsPmm)], [svg2cagX(bx, svgUnitsPmm), svg2cagY(by, svgUnitsPmm)], [svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]] }, paths[pathName])
           const rf = reflect(bx, by, cx, cy)
           bx = rf[0]
@@ -342,13 +360,14 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
         }
         break
       case 'S': // absolute cubic Bézier shorthand
-        while (pts.length >= 4) {
+        while (pts.length >= i + 4) {
           const x1 = bx // reflection of 2nd control point from previous C
           const y1 = by // reflection of 2nd control point from previous C
-          bx = parseFloat(pts.shift())
-          by = parseFloat(pts.shift())
-          cx = parseFloat(pts.shift())
-          cy = parseFloat(pts.shift())
+          bx = parseFloat(pts[i++])
+          by = parseFloat(pts[i++])
+          cx = parseFloat(pts[i++])
+          cy = parseFloat(pts[i++])
+          ensurePath()
           paths[pathName] = geometries.path2.appendBezier({ segments, controlPoints: [[svg2cagX(x1, svgUnitsPmm), svg2cagY(y1, svgUnitsPmm)], [svg2cagX(bx, svgUnitsPmm), svg2cagY(by, svgUnitsPmm)], [svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]] }, paths[pathName])
           const rf = reflect(bx, by, cx, cy)
           bx = rf[0]
@@ -356,41 +375,41 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
         }
         break
       case 'h': // relative Horzontal line to
-        while (pts.length >= 1) {
-          cx = cx + parseFloat(pts.shift())
-          paths[pathName] = geometries.path2.appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
+        while (pts.length >= i + 1) {
+          cx = cx + parseFloat(pts[i++])
+          paths[pathName] = appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
         }
         break
       case 'H': // absolute Horzontal line to
-        while (pts.length >= 1) {
-          cx = parseFloat(pts.shift())
-          paths[pathName] = geometries.path2.appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
+        while (pts.length >= i + 1) {
+          cx = parseFloat(pts[i++])
+          paths[pathName] = appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
         }
         break
       case 'l': // relative line to
-        while (pts.length >= 2) {
-          cx = cx + parseFloat(pts.shift())
-          cy = cy + parseFloat(pts.shift())
-          paths[pathName] = geometries.path2.appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
+        while (pts.length >= i + 2) {
+          cx = cx + parseFloat(pts[i++])
+          cy = cy + parseFloat(pts[i++])
+          paths[pathName] = appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
         }
         break
       case 'L': // absolute line to
-        while (pts.length >= 2) {
-          cx = parseFloat(pts.shift())
-          cy = parseFloat(pts.shift())
-          paths[pathName] = geometries.path2.appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
+        while (pts.length >= i + 2) {
+          cx = parseFloat(pts[i++])
+          cy = parseFloat(pts[i++])
+          paths[pathName] = appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
         }
         break
       case 'v': // relative Vertical line to
-        while (pts.length >= 1) {
-          cy = cy + parseFloat(pts.shift())
-          paths[pathName] = geometries.path2.appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
+        while (pts.length >= i + 1) {
+          cy = cy + parseFloat(pts[i++])
+          paths[pathName] = appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
         }
         break
       case 'V': // absolute Vertical line to
-        while (pts.length >= 1) {
-          cy = parseFloat(pts.shift())
-          paths[pathName] = geometries.path2.appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
+        while (pts.length >= i + 1) {
+          cy = parseFloat(pts[i++])
+          paths[pathName] = appendPoints([[svg2cagX(cx, svgUnitsPmm), svg2cagY(cy, svgUnitsPmm)]], paths[pathName])
         }
         break
       case 'z': // close current line
@@ -404,7 +423,25 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
         console.log('Warning: Unknow PATH command [' + co.c + ']')
         break
     }
-    // console.log('postion: ['+cx+','+cy+'] after '+co.c);
+
+    const isCloseCmd = (cmd) => cmd === 'z' || cmd === 'Z'
+
+    if (pc !== true && paths[pathName] && paths[pathName].isClosed) {
+      let coNext = obj.commands[j + 1]
+
+      if (!coNext || !isCloseCmd(coNext.c)) {
+        if (pathSelfClosed === 'trim') {
+          while (coNext && !isCloseCmd(coNext.c)) {
+            j++
+            coNext = obj.commands[j + 1]
+          }
+        } else if (pathSelfClosed === 'split') {
+          newPath()
+        } else {
+          throw new Error(`Malformed svg path at ${obj.position[0]}:${co.pos}. Path closed itself with command #${j} ${co.c}${pts.join(' ')}`)
+        }
+      }
+    }
   }
   return paths
 }

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

@@ -1,7 +1,6 @@
 const { svg2cagX, svg2cagY, cagLengthX, cagLengthY, cagLengthP, reflect } = require('./helpers')
-// const { cssPxUnit } = require('./constants')
 
-const shapesMap = function (obj, codify, params) {
+const shapesMap = (obj, codify, params) => {
   const { level, indent, on, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, target, segments } = params
 
   const types = {

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

@@ -1,60 +1,61 @@
 const { cagColor, cssStyle, css2cag } = require('./helpers')
 const { pxPmm } = require('./constants')
 
-const svgCore = function (obj, element) {
-  if ('ID' in element) { obj.id = element.ID }
+const svgCore = (obj, element) => {
+  if ('id' in element) { obj.id = element.id }
   if ('position' in element) { obj.position = element.position }
 }
 
-const svgPresentation = function (obj, element) {
+const svgPresentation = (obj, element) => {
   // presentation attributes for all
-  if ('DISPLAY' in element) { obj.visible = element.DISPLAY }
+  if ('display' in element) { obj.visible = element.display }
   // presentation attributes for solids
-  if ('COLOR' in element) { obj.fill = cagColor(element.COLOR); obj.stroke = obj.fill }
-  if ('OPACITY' in element) { obj.opacity = element.OPACITY }
-  if ('FILL' in element) {
-    obj.fill = cagColor(element.FILL)
+  if ('color' in element) { obj.fill = cagColor(element.color); obj.stroke = obj.fill }
+  if ('opacity' in element) { obj.opacity = element.opacity }
+  if ('fill' in element) {
+    obj.fill = cagColor(element.fill)
   } else {
     const s = cssStyle(element, 'fill')
     if (s) {
       obj.fill = cagColor(s)
     }
   }
-  if ('FILL-OPACITY' in element) { obj.opacity = element['FILL-OPACITY'] }
+  if ('fill-opacity' in element) { obj.opacity = element['fill-opacity'] }
   // presentation attributes for lines
-  if ('STROKE-WIDTH' in element) {
-    obj.strokeWidth = element['STROKE-WIDTH']
+  if ('stroke-width' in element) {
+    obj.strokeWidth = element['stroke-width']
   } else {
     const sw = cssStyle(element, 'stroke-width')
     if (sw) {
       obj.strokeWidth = sw
     }
   }
-  if ('STROKE' in element) {
-    obj.stroke = cagColor(element.STROKE)
+  if ('stroke' in element) {
+    obj.stroke = cagColor(element.stroke)
   } else {
     const s = cssStyle(element, 'stroke')
     if (s) {
       obj.stroke = cagColor(s)
     }
   }
-  if ('STROKE-OPACITY' in element) { obj.strokeOpacity = element['STROKE-OPACITY'] }
+  if ('stroke-opacity' in element) { obj.strokeOpacity = element['stroke-opacity'] }
 }
 
-const svgTransforms = function (cag, element) {
+const svgTransformsRegExp = /\w+\(.+\)/i
+
+const svgTransforms = (cag, element) => {
   let list = null
-  if ('TRANSFORM' in element) {
-    list = element.TRANSFORM
+  if ('transform' in element) {
+    list = element.transform
   } else {
     const s = cssStyle(element, 'transform')
     if (s) { list = s }
   }
   if (list !== null) {
     cag.transforms = []
-    const exp = new RegExp('\\w+\\(.+\\)', 'i')
-    let v = exp.exec(list)
+    let v = svgTransformsRegExp.exec(list)
     while (v !== null) {
-      const s = exp.lastIndex
+      const s = svgTransformsRegExp.lastIndex
       const e = list.indexOf(')') + 1
       let t = list.slice(s, e) // the transform
       t = t.trim()
@@ -87,29 +88,30 @@ const svgTransforms = function (cag, element) {
       }
       // shorten the list and continue
       list = list.slice(e, list.length)
-      v = exp.exec(list)
+      v = svgTransformsRegExp.exec(list)
     }
   }
 }
 
-const svgSvg = function (element, { customPxPmm }) {
+const viewBoxRegExp = /([\d.-]+)[\s,]+([\d.-]+)[\s,]+([\d.-]+)[\s,]+([\d.-]+)/i
+
+const svgSvg = (element, { customPxPmm }) => {
   // default SVG with no viewport
   const obj = { type: 'svg', x: 0, y: 0, width: '100%', height: '100%', strokeWidth: '1' }
 
   // default units per mm
   obj.unitsPmm = [pxPmm, pxPmm]
 
-  if ('PXPMM' in element) {
+  if ('pxpmm' in element) {
     // WOW! a supplied value for pixels per milimeter!!!
-    obj.pxPmm = element.PXPMM
+    obj.pxPmm = element.pxpmm
     obj.unitsPmm = [obj.pxPmm, obj.pxPmm]
   }
-  if ('WIDTH' in element) { obj.width = element.WIDTH }
-  if ('HEIGHT' in element) { obj.height = element.HEIGHT }
-  if ('VIEWBOX' in element) {
-    const list = element.VIEWBOX.trim()
-    const exp = new RegExp('([\\d\\.\\-]+)[\\s,]+([\\d\\.\\-]+)[\\s,]+([\\d\\.\\-]+)[\\s,]+([\\d\\.\\-]+)', 'i')
-    const v = exp.exec(list)
+  if ('width' in element) { obj.width = element.width }
+  if ('height' in element) { obj.height = element.height }
+  if ('viewBox' in element) {
+    const list = element.viewBox.trim()
+    const v = viewBoxRegExp.exec(list)
     if (v !== null) {
       obj.viewX = parseFloat(v[1])
       obj.viewY = parseFloat(v[2])
@@ -158,12 +160,12 @@ const svgSvg = function (element, { customPxPmm }) {
   return obj
 }
 
-const svgEllipse = function (element) {
+const svgEllipse = (element) => {
   const obj = { type: 'ellipse', cx: '0', cy: '0', rx: '0', ry: '0' }
-  if ('CX' in element) { obj.cx = element.CX }
-  if ('CY' in element) { obj.cy = element.CY }
-  if ('RX' in element) { obj.rx = element.RX }
-  if ('RY' in element) { obj.ry = element.RY }
+  if ('cx' in element) { obj.cx = element.cx }
+  if ('cy' in element) { obj.cy = element.cy }
+  if ('rx' in element) { obj.rx = element.rx }
+  if ('ry' in element) { obj.ry = element.ry }
   // transforms
   svgTransforms(obj, element)
   // core attributes
@@ -173,12 +175,12 @@ const svgEllipse = function (element) {
   return obj
 }
 
-const svgLine = function (element) {
+const svgLine = (element) => {
   const obj = { type: 'line', x1: '0', y1: '0', x2: '0', y2: '0' }
-  if ('X1' in element) { obj.x1 = element.X1 }
-  if ('Y1' in element) { obj.y1 = element.Y1 }
-  if ('X2' in element) { obj.x2 = element.X2 }
-  if ('Y2' in element) { obj.y2 = element.Y2 }
+  if ('x1' in element) { obj.x1 = element.x1 }
+  if ('y1' in element) { obj.y1 = element.y1 }
+  if ('x2' in element) { obj.x2 = element.x2 }
+  if ('y2' in element) { obj.y2 = element.y2 }
   // transforms
   svgTransforms(obj, element)
   // core attributes
@@ -188,9 +190,9 @@ const svgLine = function (element) {
   return obj
 }
 
-const svgListOfPoints = function (list) {
+const svgListOfPoints = (list) => {
   const points = []
-  const exp = new RegExp('([\\d\\-\\+\\.]+)[\\s,]+([\\d\\-\\+\\.]+)[\\s,]*', 'i')
+  const exp = /([\d\-+.]+)[\s,]+([\d\-+.]+)[\s,]*/i
   list = list.trim()
   let v = exp.exec(list)
   while (v !== null) {
@@ -204,7 +206,7 @@ const svgListOfPoints = function (list) {
   return points
 }
 
-const svgPolyline = function (element) {
+const svgPolyline = (element) => {
   const obj = { type: 'polyline' }
   // transforms
   svgTransforms(obj, element)
@@ -213,13 +215,13 @@ const svgPolyline = function (element) {
   // presentation attributes
   svgPresentation(obj, element)
 
-  if ('POINTS' in element) {
-    obj.points = svgListOfPoints(element.POINTS)
+  if ('points' in element) {
+    obj.points = svgListOfPoints(element.points)
   }
   return obj
 }
 
-const svgPolygon = function (element) {
+const svgPolygon = (element) => {
   const obj = { type: 'polygon' }
   // transforms
   svgTransforms(obj, element)
@@ -228,30 +230,30 @@ const svgPolygon = function (element) {
   // presentation attributes
   svgPresentation(obj, element)
 
-  if ('POINTS' in element) {
-    obj.points = svgListOfPoints(element.POINTS)
+  if ('points' in element) {
+    obj.points = svgListOfPoints(element.points)
   }
   return obj
 }
 
-const svgRect = function (element) {
+const svgRect = (element) => {
   const obj = { type: 'rect', x: '0', y: '0', rx: '0', ry: '0', width: '0', height: '0' }
 
-  if ('X' in element) { obj.x = element.X }
-  if ('Y' in element) { obj.y = element.Y }
-  if ('RX' in element) {
-    obj.rx = element.RX
-    if (!('RY' in element)) { obj.ry = obj.rx } // by SVG specification
+  if ('x' in element) { obj.x = element.x }
+  if ('y' in element) { obj.y = element.y }
+  if ('rx' in element) {
+    obj.rx = element.rx
+    if (!('ry' in element)) { obj.ry = obj.rx } // by SVG specification
   }
-  if ('RY' in element) {
-    obj.ry = element.RY
-    if (!('RX' in element)) { obj.rx = obj.ry } // by SVG specification
+  if ('ry' in element) {
+    obj.ry = element.ry
+    if (!('rx' in element)) { obj.rx = obj.ry } // by SVG specification
   }
   if (obj.rx !== obj.ry) {
-    console.log('Warning: Unsupported RECT with RX and RY radius')
+    console.log('Warning: Unsupported RECT with rx and ry radius')
   }
-  if ('WIDTH' in element) { obj.width = element.WIDTH }
-  if ('HEIGHT' in element) { obj.height = element.HEIGHT }
+  if ('width' in element) { obj.width = element.width }
+  if ('height' in element) { obj.height = element.height }
   // transforms
   svgTransforms(obj, element)
   // core attributes
@@ -261,12 +263,12 @@ const svgRect = function (element) {
   return obj
 }
 
-const svgCircle = function (element) {
+const svgCircle = (element) => {
   const obj = { type: 'circle', x: '0', y: '0', radius: '0' }
 
-  if ('CX' in element) { obj.x = element.CX }
-  if ('CY' in element) { obj.y = element.CY }
-  if ('R' in element) { obj.radius = element.R }
+  if ('cx' in element) { obj.x = element.cx }
+  if ('cy' in element) { obj.y = element.cy }
+  if ('r' in element) { obj.radius = element.r }
   // transforms
   svgTransforms(obj, element)
   // core attributes
@@ -276,7 +278,7 @@ const svgCircle = function (element) {
   return obj
 }
 
-const svgGroup = function (element) {
+const svgGroup = (element) => {
   const obj = { type: 'group' }
   // transforms
   svgTransforms(obj, element)
@@ -285,11 +287,11 @@ const svgGroup = function (element) {
   // presentation attributes
   svgPresentation(obj, element)
 
-  if ('X' in element || 'Y' in element) {
+  if ('x' in element || 'y' in element) {
     let x = '0'
     let y = '0'
-    if ('X' in element) x = element.X
-    if ('Y' in element) y = element.Y
+    if ('x' in element) x = element.x
+    if ('y' in element) y = element.y
     if (!('transforms' in obj)) obj.transforms = []
     const o = { translate: [x, y] }
     obj.transforms.push(o)
@@ -302,7 +304,7 @@ const svgGroup = function (element) {
 //
 // Convert the PATH element into object representation
 //
-const svgPath = function (element) {
+const svgPath = (element) => {
   const obj = { type: 'path' }
   // transforms
   svgTransforms(obj, element)
@@ -312,14 +314,15 @@ const svgPath = function (element) {
   svgPresentation(obj, element)
 
   obj.commands = []
-  if ('D' in element) {
+  if ('d' in element) {
     let co = null // current command
     let bf = ''
 
     let i = 0
-    const l = element.D.length
+    const l = element.d.length
+    const offset = element.position[1] - l - 2
     while (i < l) {
-      const c = element.D[i]
+      const c = element.d[i]
       switch (c) {
       // numbers
       // FIXME support E notation numbers
@@ -379,7 +382,7 @@ const svgPath = function (element) {
             }
             obj.commands.push(co)
           }
-          co = { c: c, p: [] }
+          co = { c: c, p: [], pos: i + offset }
           break
         // white space
         case ',':
@@ -408,11 +411,11 @@ const svgPath = function (element) {
 }
 
 // generate GROUP with attributes from USE element
-// - expect X,Y,HEIGHT,WIDTH,XLINK:HREF
-// - append translate(x,y) if X,Y available
+// - expect x,y,height,width,XLINK:HREF
+// - append translate(x,y) if x,y available
 // deep clone the referenced OBJECT and add to group
 // - clone using JSON.parse(JSON.stringify(obj))
-const svgUse = function (element, { svgObjects }) {
+const svgUse = (element, { svgObjects }) => {
   const obj = { type: 'group' }
   // transforms
   svgTransforms(obj, element)
@@ -421,20 +424,20 @@ const svgUse = function (element, { svgObjects }) {
   // presentation attributes
   svgPresentation(obj, element)
 
-  if ('X' in element || 'Y' in element) {
+  if ('x' in element || 'y' in element) {
     let x = '0'
     let y = '0'
-    if ('X' in element) x = element.X
-    if ('Y' in element) y = element.Y
+    if ('x' in element) x = element.x
+    if ('y' in element) y = element.y
     if (!('transforms' in obj)) obj.transforms = []
     const o = { translate: [x, y] }
     obj.transforms.push(o)
   }
 
   obj.objects = []
-  if ('XLINK:HREF' in element) {
+  if ('xlink:href' in element) {
   // lookup the named object
-    let ref = element['XLINK:HREF']
+    let ref = element['xlink:href']
     if (ref[0] === '#') { ref = ref.slice(1, ref.length) }
     if (svgObjects[ref] !== undefined) {
       ref = svgObjects[ref]

package/tests/inkscape.test.js

@@ -2,13 +2,12 @@ const test = require('ava')
 
 const countOf = require('../../test/helpers/countOf')
 
-const deserializer = require('../index.js')
+const deserializer = require('../src/index.js')
 
 // deserializer
 
 test('deserialize : translate svg produced by inkscape to script', (t) => {
-  const sourceSvg = `
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+  const sourceSvg = `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <svg
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:cc="http://creativecommons.org/ns#"

package/tests/instantiate.test.js

@@ -1,12 +1,13 @@
 const test = require('ava')
 
-const deserializer = require('../index.js')
+const deserializer = require('../src/index.js')
+
 const { measurements } = require('@jscad/modeling')
 
 // deserializer
 
 test('deserialize : instantiate svg (rect) to objects', (t) => {
-  const sourceSvg = `<svg PXPMM="10" width="500" height="500">
+  const sourceSvg = `<svg pxpmm="10" width="500" height="500">
   <rect x="80" y="60" width="250" height="250" color="red"/>
   <rect x="140" y="120" width="250" height="250" rx="40" color="rgb(0,255,0)"/>
   <rect x="140" y="120" width="250" height="250" ry="40" color="blue"/>
@@ -149,7 +150,7 @@ test('deserialize : instantiate svg (line) to objects', (t) => {
   t.is(shape.points.length, 2)
 
   // test getting stroke width from group
-  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120"">
+  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120">
   <g stroke-width="2">
     <line x1="20" y1="100" x2="100" y2="20" stroke="black"/>
   </g>
@@ -180,7 +181,7 @@ test('deserialize : instantiate svg (path: simple) to objects', (t) => {
   t.is(shape.points.length, 3)
 
   // test getting stroke width from group
-  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120"">
+  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120">
   <g stroke-width="2">
     <path d="M150 0 L75 200 L225 200 Z" />
   </g>
@@ -210,7 +211,7 @@ test('deserialize : instantiate svg (path: simple) to objects', (t) => {
   shape = observed[0]
   t.is(shape.points.length, 3)
 
-  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120"">
+  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120">
   <path d="M 240.00000 56.00000 H 270.00000 V 86.00000 H 300.00000 V 116.00000 H 330.00000 V 146.00000 H 240.00000 V 56.00000 Z"/>
 </svg>`
 
@@ -247,10 +248,10 @@ test('deserialize : instantiate svg (path: arc) to objects', (t) => {
   t.is(observed.length, 2)
   shape = observed[0]
   t.is(shape.points.length, 15) // segments double on a 3/4 circle
-  t.deepEqual(measurements.measureBoundingBox(shape), [[64.91110599999999, -77.611103, 0], [90.21850570104527, -52.30370029895471, 0]])
+  t.deepEqual(measurements.measureBoundingBox(shape), [[64.91110599999999, -77.611105, 0], [90.21850570104527, -52.30370029895471, 0]])
   shape = observed[1]
   t.is(shape.points.length, 15) // segments double on a 3/4 circle
-  t.deepEqual(measurements.measureBoundingBox(shape), [[50.79999599999999, -136.03302387090216, 0], [72.27222493929787, -110.6793647936299, 0]])
+  t.deepEqual(measurements.measureBoundingBox(shape), [[50.799996, -136.03302387090216, 0], [72.27222493929787, -110.6793647936299, 0]])
 })
 
 // ################################
@@ -360,8 +361,7 @@ test('deserialize : instantiate svg (path: with bezier) to objects', (t) => {
 // ################################
 
 test('deserialize : instantiate svg produced by inkscape to objects', (t) => {
-  const sourceSvg = `
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+  const sourceSvg = `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <svg
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:cc="http://creativecommons.org/ns#"
@@ -434,16 +434,16 @@ test('deserialize : instantiate shape with a hole to objects', (t) => {
   let observed = deserializer.deserialize({ output: 'geometry', target: 'geom2', addMetaData: false }, sourceSvg)
   t.is(observed.length, 2)
   let shape = observed[0]
-  t.is(shape.sides.length, 39)
+  t.is(shape.sides.length, 38)
   shape = observed[1]
-  t.is(shape.sides.length, 39)
+  t.is(shape.sides.length, 38)
 
   observed = deserializer.deserialize({ output: 'geometry', target: 'path', addMetaData: false }, sourceSvg)
   t.is(observed.length, 2)
   shape = observed[0]
-  t.is(shape.points.length, 39)
+  t.is(shape.points.length, 38)
   shape = observed[1]
-  t.is(shape.points.length, 39)
+  t.is(shape.points.length, 38)
 })
 
 // ################################
@@ -458,12 +458,12 @@ test('deserialize : instantiate shape with a nested hole to objects', (t) => {
   let observed = deserializer.deserialize({ output: 'geometry', target: 'geom2', addMetaData: false }, sourceSvg)
   t.is(observed.length, 4)
   let shape = observed[0]
-  t.is(shape.sides.length, 39)
+  t.is(shape.sides.length, 38)
 
   observed = deserializer.deserialize({ output: 'geometry', target: 'path', addMetaData: false }, sourceSvg)
   t.is(observed.length, 4)
   shape = observed[0]
-  t.is(shape.points.length, 39)
+  t.is(shape.points.length, 38)
 })
 
 // ################################

package/tests/issue.885.test.js

@@ -0,0 +1,23 @@
+const test = require('ava')
+
+const deserializer = require('../src/index.js')
+
+// deserializer
+
+// ################################
+
+test('deserialize issue 885', (t) => {
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="5.791015625" height="11.71875">
+    <path d="M1.84-3.17L0.53-3.48L0.97-7.11L5.12-7.11L5.12-5.83L2.30-5.83L2.14-4.42Q2.32-4.52 2.60-4.60Q2.89-4.68 3.16-4.68L3.16-4.68Q4.22-4.68 4.79-4.05Q5.36-3.42 5.36-2.29L5.36-2.29Q5.36-1.61 5.06-1.05Q4.75-0.50 4.20-0.20Q3.65 0.10 2.90 0.10L2.90 0.10Q2.23 0.10 1.64-0.18Q1.05-0.45 0.72-0.94Q0.39-1.42 0.40-2.02L0.40-2.02L2.05-2.02Q2.07-1.63 2.29-1.40Q2.52-1.17 2.89-1.17L2.89-1.17Q3.72-1.17 3.72-2.40L3.72-2.40Q3.72-3.54 2.70-3.54L2.70-3.54Q2.12-3.54 1.84-3.17L1.84-3.17Z"/>
+  </svg>`
+
+  t.throws(() => {
+    deserializer.deserialize({ output: 'geometry' }, svg)
+  }, { instanceOf: Error }, 'Malformed svg path at 2:445. Path closed itself with command #29: "Q2.12 -3.54 1.84 -3.17". to avoid this error use pathSelfClosed:\'split\' or pathSelfClosed:\'trim\' option')
+
+  let shapes = deserializer.deserialize({ output: 'geometry', pathSelfClosed: 'split' }, svg)
+  t.is(shapes.length, 2)
+
+  shapes = deserializer.deserialize({ output: 'geometry', pathSelfClosed: 'trim' }, svg)
+  t.is(shapes.length, 1)
+})

package/tests/translate.test.js

@@ -2,14 +2,14 @@ const test = require('ava')
 
 const countOf = require('../../test/helpers/countOf')
 
-const deserializer = require('../index.js')
+const deserializer = require('../src/index.js')
 
 // deserializer
 
 // ################################
 
 test('deserialize : translate svg (rect) to script', (t) => {
-  const sourceSvg = `<svg PXPMM="10" width="500" height="500">
+  const sourceSvg = `<svg pxpmm="10" width="500" height="500">
   <rect x="80" y="60" width="250" height="250" color="red"/>
   <rect x="140" y="120" width="250" height="250" rx="40" color="rgb(0,255,0)"/>
   <rect x="140" y="120" width="250" height="250" ry="40" color="blue"/>
@@ -88,7 +88,7 @@ test('deserialize : translate svg (line) to script', (t) => {
   // TODO
 
   // test getting stroke width from group
-  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120"">
+  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120">
   <g stroke-width="2">
     <line x1="20" y1="100" x2="100" y2="20" stroke="black"/>
   </g>
@@ -133,7 +133,7 @@ test('deserialize : translate svg (polyline) to script', (t) => {
   // FIXME t.is(countOf('path2.fromPoints', obs), 1)
 
   // test getting stroke width from group
-  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120"">
+  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120">
   <g stroke-width="2">
     <polyline fill="none" stroke="black" points="20,100 40,60 70,80 100,20"/>
   </g>
@@ -168,7 +168,7 @@ test('deserialize : translate svg (path: simple) to script', (t) => {
   t.is(countOf('geom2.fromPoints', obs), 1)
 
   // test getting stroke width from group
-  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120"">
+  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120">
   <g stroke-width="2">
     <path d="M150 0 L75 200 L225 200 Z" />
   </g>
@@ -190,7 +190,7 @@ test('deserialize : translate svg (path: simple) to script', (t) => {
   t.is(countOf('path2.close', obs), 1)
   t.is(countOf('geom2.fromPoints', obs), 0)
 
-  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120"">
+  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120">
   <path fill="#ff8000" d="m 240.00000 190.00000 h 30.00000 v 30.00000 h 30.00000 v 30.00000 h 30.00000 v 30.00000 h -90.00000 v -90.00000 z"/>
 </svg>`
 
@@ -202,7 +202,7 @@ test('deserialize : translate svg (path: simple) to script', (t) => {
   t.is(countOf('geom2.fromPoints', obs), 1)
   t.is(countOf('colors.colorize', obs), 1) // fill
 
-  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120"">
+  sourceSvg = `<svg width="120" height="120" viewBox="0 0 120 120">
   <path d="M 240.00000 56.00000 H 270.00000 V 86.00000 H 300.00000 V 116.00000 H 330.00000 V 146.00000 H 240.00000 V 56.00000 Z"/>
 </svg>`