diff --git a/packages/plugin-bundle/.babelrc b/packages/plugin-bundle/.babelrc
new file mode 100644
index 00000000000..6ecb268f939
--- /dev/null
+++ b/packages/plugin-bundle/.babelrc
@@ -0,0 +1,4 @@
+{
+  "presets": ["@babel/preset-env"]
+}
+
diff --git a/packages/plugin-bundle/package.json b/packages/plugin-bundle/package.json
index 5ad6bb2c4f4..1d22a927376 100644
--- a/packages/plugin-bundle/package.json
+++ b/packages/plugin-bundle/package.json
@@ -31,7 +31,7 @@
     "clean": "rimraf dist",
     "build": "rollup -c",
     "lernabuild": "rollup -c",
-    "test": "echo \"plugin-bundle: No tests configured. Perhaps you'd like to do this?\" && exit 0",
+    "test": "BABEL_ENV=production ../../node_modules/.bin/mocha tests/*.test.js --require @babel/register",
     "pubtest": "npm publish --registry http://localhost:6662",
     "pubforce": "npm publish",
     "symlink": "mkdir -p ./node_modules/@freesewing && cd ./node_modules/@freesewing && ln -s -f ../../../* . && cd -",
diff --git a/packages/plugin-bundle/tests/bundle.test.js b/packages/plugin-bundle/tests/bundle.test.js
index 6990a9b1a0a..664dee01d55 100644
--- a/packages/plugin-bundle/tests/bundle.test.js
+++ b/packages/plugin-bundle/tests/bundle.test.js
@@ -1,4 +1,4 @@
-import freesewing from "freesewing";
+import freesewing from "@freesewing/core";
 let expect = require("chai").expect;
 let plugin = require("../dist/index.js");
 let bundle = [
diff --git a/packages/plugin-bundle/tests/cutonfold.test.js b/packages/plugin-bundle/tests/cutonfold.test.js
index 5a6a7c16485..04d6285764a 100644
--- a/packages/plugin-bundle/tests/cutonfold.test.js
+++ b/packages/plugin-bundle/tests/cutonfold.test.js
@@ -1,62 +1,64 @@
-import freesewing from "freesewing";
-import { version } from "../node_modules/@freesewing/plugin-cutonfold/package.json";
+import freesewing from "@freesewing/core";
+import { version } from "../../plugin-cutonfold/package.json";
 let expect = require("chai").expect;
 let plugin = require("../dist/index.js");
 
-it("Should set the plugin name:version attribute", () => {
-  let pattern = new freesewing.Pattern().use(plugin);
-  pattern.render();
-  expect(pattern.svg.attributes.get("freesewing:plugin-cutonfold")).to.equal(
-    version
-  );
-});
-
-it("Should run the default cutonfold macro", () => {
-  let pattern = new freesewing.Pattern();
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.from = new pattern.Point(10, 20);
-  pattern.parts.test.points.to = new pattern.Point(10, 230);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("cutonfold", {
-    from: pattern.parts.test.points.from,
-    to: pattern.parts.test.points.to
+describe("plugin-cutonfold", function() {
+  it("Should set the plugin name:version attribute", () => {
+    let pattern = new freesewing.Pattern().use(plugin);
+    pattern.render();
+    expect(pattern.svg.attributes.get("freesewing:plugin-cutonfold")).to.equal(
+      version
+    );
   });
-  let c = pattern.parts.test.paths.cutonfold;
-  console.log(c.ops);
-  expect(c.attributes.get("class")).to.equal("note");
-  expect(c.attributes.get("marker-start")).to.equal("url(#cutonfoldFrom)");
-  expect(c.attributes.get("marker-end")).to.equal("url(#cutonfoldTo)");
-  expect(c.attributes.get("data-text")).to.equal("cutOnFold");
-  expect(c.attributes.get("data-text-class")).to.equal("center fill-note");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[2].type).to.equal("line");
-  expect(c.ops[3].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(10);
-  expect(c.ops[0].to.y).to.equal(200);
-  expect(c.ops[1].to.x).to.equal(30);
-  expect(c.ops[1].to.y).to.equal(200);
-  expect(c.ops[2].to.x).to.equal(30);
-  expect(c.ops[2].to.y).to.equal(50);
-  expect(c.ops[3].to.x).to.equal(10);
-  expect(c.ops[3].to.y).to.equal(50);
-});
-
-it("Should run the cutonfold/grainline macro", () => {
-  let pattern = new freesewing.Pattern();
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.from = new pattern.Point(10, 20);
-  pattern.parts.test.points.to = new pattern.Point(10, 230);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("cutonfold", {
-    from: pattern.parts.test.points.from,
-    to: pattern.parts.test.points.to,
-    grainline: true
+  
+  it("Should run the default cutonfold macro", () => {
+    let pattern = new freesewing.Pattern();
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.from = new pattern.Point(10, 20);
+    pattern.parts.test.points.to = new pattern.Point(10, 230);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("cutonfold", {
+      from: pattern.parts.test.points.from,
+      to: pattern.parts.test.points.to
+    });
+    let c = pattern.parts.test.paths.cutonfold;
+    console.log(c.ops);
+    expect(c.attributes.get("class")).to.equal("note");
+    expect(c.attributes.get("marker-start")).to.equal("url(#cutonfoldFrom)");
+    expect(c.attributes.get("marker-end")).to.equal("url(#cutonfoldTo)");
+    expect(c.attributes.get("data-text")).to.equal("cutOnFold");
+    expect(c.attributes.get("data-text-class")).to.equal("center fill-note");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[2].type).to.equal("line");
+    expect(c.ops[3].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(10);   //needs to be rounded 
+    expect(c.ops[0].to.y).to.equal(200);
+    expect(c.ops[1].to.x).to.equal(30);
+    expect(c.ops[1].to.y).to.equal(200);
+    expect(c.ops[2].to.x).to.equal(30);
+    expect(c.ops[2].to.y).to.equal(50);
+    expect(c.ops[3].to.x).to.equal(10);
+    expect(c.ops[3].to.y).to.equal(50);
+  });
+  
+  it("Should run the cutonfold/grainline macro", () => {
+    let pattern = new freesewing.Pattern();
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.from = new pattern.Point(10, 20);
+    pattern.parts.test.points.to = new pattern.Point(10, 230);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("cutonfold", {
+      from: pattern.parts.test.points.from,
+      to: pattern.parts.test.points.to,
+      grainline: true
+    });
+    let c = pattern.parts.test.paths.cutonfold;
+    expect(c.attributes.get("data-text")).to.equal("cutOnFoldAndGrainline");
   });
-  let c = pattern.parts.test.paths.cutonfold;
-  expect(c.attributes.get("data-text")).to.equal("cutOnFoldAndGrainline");
 });
diff --git a/packages/plugin-bundle/tests/dimension.test.js b/packages/plugin-bundle/tests/dimension.test.js
index 07f9a758669..83826a96c8d 100644
--- a/packages/plugin-bundle/tests/dimension.test.js
+++ b/packages/plugin-bundle/tests/dimension.test.js
@@ -1,185 +1,187 @@
-import freesewing from "freesewing";
-import { version } from "../node_modules/@freesewing/plugin-dimension/package.json";
+import freesewing from "@freesewing/core";
+import { version } from "../../plugin-dimension/package.json";
 let expect = require("chai").expect;
 let plugin = require("../dist/index.js");
 
-it("Should set the plugin name:version attribute", () => {
-  let pattern = new freesewing.Pattern().use(plugin);
-  pattern.render();
-  expect(pattern.svg.attributes.get("freesewing:plugin-dimension")).to.equal(
-    version
-  );
-});
-
-it("Should run the hd macro", () => {
-  let pattern = new freesewing.Pattern();
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.from = new pattern.Point(10, 20);
-  pattern.parts.test.points.to = new pattern.Point(200, 20);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("hd", {
-    from: pattern.parts.test.points.from,
-    to: pattern.parts.test.points.to,
-    y: 35
+describe("plugin-dimension", function() {
+  it("Should set the plugin name:version attribute", () => {
+    let pattern = new freesewing.Pattern().use(plugin);
+    pattern.render();
+    expect(pattern.svg.attributes.get("freesewing:plugin-dimension")).to.equal(
+      version
+    );
   });
-  let c = pattern.parts.test.paths[1];
-  expect(c.attributes.get("class")).to.equal("mark");
-  expect(c.attributes.get("marker-start")).to.equal("url(#dimensionFrom)");
-  expect(c.attributes.get("marker-end")).to.equal("url(#dimensionTo)");
-  expect(c.attributes.get("data-text")).to.equal("19cm");
-  expect(c.attributes.get("data-text-class")).to.equal("fill-mark center");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(10);
-  expect(c.ops[0].to.y).to.equal(35);
-  expect(c.ops[1].to.x).to.equal(200);
-  expect(c.ops[1].to.y).to.equal(35);
-  c = pattern.parts.test.paths["1_ls"];
-  expect(c.attributes.get("class")).to.equal("mark dotted");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(10);
-  expect(c.ops[0].to.y).to.equal(20);
-  expect(c.ops[1].to.x).to.equal(10);
-  expect(c.ops[1].to.y).to.equal(35);
-  c = pattern.parts.test.paths["1_le"];
-  expect(c.attributes.get("class")).to.equal("mark dotted");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(200);
-  expect(c.ops[0].to.y).to.equal(20);
-  expect(c.ops[1].to.x).to.equal(200);
-  expect(c.ops[1].to.y).to.equal(35);
-});
-
-it("Should run the vd macro", () => {
-  let pattern = new freesewing.Pattern();
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.from = new pattern.Point(10, 20);
-  pattern.parts.test.points.to = new pattern.Point(10, 200);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("vd", {
-    from: pattern.parts.test.points.from,
-    to: pattern.parts.test.points.to,
-    x: 25
+  
+  it("Should run the hd macro", () => {
+    let pattern = new freesewing.Pattern();
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.from = new pattern.Point(10, 20);
+    pattern.parts.test.points.to = new pattern.Point(200, 20);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("hd", {
+      from: pattern.parts.test.points.from,
+      to: pattern.parts.test.points.to,
+      y: 35
+    });
+    let c = pattern.parts.test.paths[1];
+    expect(c.attributes.get("class")).to.equal("mark");
+    expect(c.attributes.get("marker-start")).to.equal("url(#dimensionFrom)");
+    expect(c.attributes.get("marker-end")).to.equal("url(#dimensionTo)");
+    expect(c.attributes.get("data-text")).to.equal("19cm");
+    expect(c.attributes.get("data-text-class")).to.equal("fill-mark center");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(10);
+    expect(c.ops[0].to.y).to.equal(35);
+    expect(c.ops[1].to.x).to.equal(200);
+    expect(c.ops[1].to.y).to.equal(35);
+    c = pattern.parts.test.paths["1_ls"];
+    expect(c.attributes.get("class")).to.equal("mark dotted");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(10);
+    expect(c.ops[0].to.y).to.equal(20);
+    expect(c.ops[1].to.x).to.equal(10);
+    expect(c.ops[1].to.y).to.equal(35);
+    c = pattern.parts.test.paths["1_le"];
+    expect(c.attributes.get("class")).to.equal("mark dotted");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(200);
+    expect(c.ops[0].to.y).to.equal(20);
+    expect(c.ops[1].to.x).to.equal(200);
+    expect(c.ops[1].to.y).to.equal(35);
   });
-  let c = pattern.parts.test.paths[1];
-  expect(c.attributes.get("class")).to.equal("mark");
-  expect(c.attributes.get("marker-start")).to.equal("url(#dimensionFrom)");
-  expect(c.attributes.get("marker-end")).to.equal("url(#dimensionTo)");
-  expect(c.attributes.get("data-text")).to.equal("18cm");
-  expect(c.attributes.get("data-text-class")).to.equal("fill-mark center");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(25);
-  expect(c.ops[0].to.y).to.equal(20);
-  expect(c.ops[1].to.x).to.equal(25);
-  expect(c.ops[1].to.y).to.equal(200);
-  c = pattern.parts.test.paths["1_ls"];
-  expect(c.attributes.get("class")).to.equal("mark dotted");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(10);
-  expect(c.ops[0].to.y).to.equal(20);
-  expect(c.ops[1].to.x).to.equal(25);
-  expect(c.ops[1].to.y).to.equal(20);
-  c = pattern.parts.test.paths["1_le"];
-  expect(c.attributes.get("class")).to.equal("mark dotted");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(10);
-  expect(c.ops[0].to.y).to.equal(200);
-  expect(c.ops[1].to.x).to.equal(25);
-  expect(c.ops[1].to.y).to.equal(200);
-});
-
-it("Should run the ld macro", () => {
-  let pattern = new freesewing.Pattern();
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.from = new pattern.Point(10, 10);
-  pattern.parts.test.points.to = new pattern.Point(100, 100);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("ld", {
-    from: pattern.parts.test.points.from,
-    to: pattern.parts.test.points.to,
-    d: 15
+  
+  it("Should run the vd macro", () => {
+    let pattern = new freesewing.Pattern();
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.from = new pattern.Point(10, 20);
+    pattern.parts.test.points.to = new pattern.Point(10, 200);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("vd", {
+      from: pattern.parts.test.points.from,
+      to: pattern.parts.test.points.to,
+      x: 25
+    });
+    let c = pattern.parts.test.paths[1];
+    expect(c.attributes.get("class")).to.equal("mark");
+    expect(c.attributes.get("marker-start")).to.equal("url(#dimensionFrom)");
+    expect(c.attributes.get("marker-end")).to.equal("url(#dimensionTo)");
+    expect(c.attributes.get("data-text")).to.equal("18cm");
+    expect(c.attributes.get("data-text-class")).to.equal("fill-mark center");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(25);
+    expect(c.ops[0].to.y).to.equal(20);
+    expect(c.ops[1].to.x).to.equal(25);
+    expect(c.ops[1].to.y).to.equal(200);
+    c = pattern.parts.test.paths["1_ls"];
+    expect(c.attributes.get("class")).to.equal("mark dotted");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(10);
+    expect(c.ops[0].to.y).to.equal(20);
+    expect(c.ops[1].to.x).to.equal(25);
+    expect(c.ops[1].to.y).to.equal(20);
+    c = pattern.parts.test.paths["1_le"];
+    expect(c.attributes.get("class")).to.equal("mark dotted");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(10);
+    expect(c.ops[0].to.y).to.equal(200);
+    expect(c.ops[1].to.x).to.equal(25);
+    expect(c.ops[1].to.y).to.equal(200);
   });
-  let c = pattern.parts.test.paths[1];
-  expect(c.attributes.get("class")).to.equal("mark");
-  expect(c.attributes.get("marker-start")).to.equal("url(#dimensionFrom)");
-  expect(c.attributes.get("marker-end")).to.equal("url(#dimensionTo)");
-  expect(c.attributes.get("data-text")).to.equal("12.73cm");
-  expect(c.attributes.get("data-text-class")).to.equal("fill-mark center");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(20.61);
-  expect(c.ops[0].to.y).to.equal(-0.61);
-  expect(c.ops[1].to.x).to.equal(110.61);
-  expect(c.ops[1].to.y).to.equal(89.39);
-  c = pattern.parts.test.paths["1_ls"];
-  expect(c.attributes.get("class")).to.equal("mark dotted");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(10);
-  expect(c.ops[0].to.y).to.equal(10);
-  expect(c.ops[1].to.x).to.equal(20.61);
-  expect(c.ops[1].to.y).to.equal(-0.61);
-  c = pattern.parts.test.paths["1_le"];
-  expect(c.attributes.get("class")).to.equal("mark dotted");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(100);
-  expect(c.ops[0].to.y).to.equal(100);
-  expect(c.ops[1].to.x).to.equal(110.61);
-  expect(c.ops[1].to.y).to.equal(89.39);
-});
-
-it("Should run the pd macro", () => {
-  let pattern = new freesewing.Pattern();
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  let from = new pattern.Point(10, 10);
-  let cp1 = new pattern.Point(100, 10);
-  let cp2 = new pattern.Point(10, 100);
-  let to = new pattern.Point(100, 100);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("pd", {
-    path: new pattern.Path().move(from).curve(cp1, cp2, to),
-    d: 15
+  
+  it("Should run the ld macro", () => {
+    let pattern = new freesewing.Pattern();
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.from = new pattern.Point(10, 10);
+    pattern.parts.test.points.to = new pattern.Point(100, 100);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("ld", {
+      from: pattern.parts.test.points.from,
+      to: pattern.parts.test.points.to,
+      d: 15
+    });
+    let c = pattern.parts.test.paths[1];
+    expect(c.attributes.get("class")).to.equal("mark");
+    expect(c.attributes.get("marker-start")).to.equal("url(#dimensionFrom)");
+    expect(c.attributes.get("marker-end")).to.equal("url(#dimensionTo)");
+    expect(c.attributes.get("data-text")).to.equal("12.73cm");
+    expect(c.attributes.get("data-text-class")).to.equal("fill-mark center");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(20.61);
+    expect(c.ops[0].to.y).to.equal(-0.61);
+    expect(c.ops[1].to.x).to.equal(110.61);
+    expect(c.ops[1].to.y).to.equal(89.39);
+    c = pattern.parts.test.paths["1_ls"];
+    expect(c.attributes.get("class")).to.equal("mark dotted");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(10);
+    expect(c.ops[0].to.y).to.equal(10);
+    expect(c.ops[1].to.x).to.equal(20.61);
+    expect(c.ops[1].to.y).to.equal(-0.61);
+    c = pattern.parts.test.paths["1_le"];
+    expect(c.attributes.get("class")).to.equal("mark dotted");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(100);
+    expect(c.ops[0].to.y).to.equal(100);
+    expect(c.ops[1].to.x).to.equal(110.61);
+    expect(c.ops[1].to.y).to.equal(89.39);
+  });
+  
+  it("Should run the pd macro", () => {
+    let pattern = new freesewing.Pattern();
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    let from = new pattern.Point(10, 10);
+    let cp1 = new pattern.Point(100, 10);
+    let cp2 = new pattern.Point(10, 100);
+    let to = new pattern.Point(100, 100);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("pd", {
+      path: new pattern.Path().move(from).curve(cp1, cp2, to),
+      d: 15
+    });
+    let c = pattern.parts.test.paths[1];
+    expect(c.attributes.get("class")).to.equal("mark");
+    expect(c.attributes.get("marker-start")).to.equal("url(#dimensionFrom)");
+    expect(c.attributes.get("marker-end")).to.equal("url(#dimensionTo)");
+    expect(c.attributes.get("data-text")).to.equal("15.09cm");
+    expect(c.attributes.get("data-text-class")).to.equal("fill-mark center");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("curve");
+    expect(c.ops[0].to.x).to.equal(10);
+    expect(c.ops[0].to.y).to.equal(25);
+    expect(c.ops[1].to.x).to.equal(37.15);
+    expect(c.ops[1].to.y).to.equal(32.79);
+    c = pattern.parts.test.paths["1_ls"];
+    expect(c.attributes.get("class")).to.equal("mark dotted");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(10);
+    expect(c.ops[0].to.y).to.equal(10);
+    expect(c.ops[1].to.x).to.equal(10);
+    expect(c.ops[1].to.y).to.equal(25);
+    c = pattern.parts.test.paths["1_le"];
+    expect(c.attributes.get("class")).to.equal("mark dotted");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(100);
+    expect(c.ops[0].to.y).to.equal(100);
+    expect(c.ops[1].to.x).to.equal(100);
+    expect(c.ops[1].to.y).to.equal(115);
   });
-  let c = pattern.parts.test.paths[1];
-  expect(c.attributes.get("class")).to.equal("mark");
-  expect(c.attributes.get("marker-start")).to.equal("url(#dimensionFrom)");
-  expect(c.attributes.get("marker-end")).to.equal("url(#dimensionTo)");
-  expect(c.attributes.get("data-text")).to.equal("15.09cm");
-  expect(c.attributes.get("data-text-class")).to.equal("fill-mark center");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("curve");
-  expect(c.ops[0].to.x).to.equal(10);
-  expect(c.ops[0].to.y).to.equal(25);
-  expect(c.ops[1].to.x).to.equal(37.15);
-  expect(c.ops[1].to.y).to.equal(32.79);
-  c = pattern.parts.test.paths["1_ls"];
-  expect(c.attributes.get("class")).to.equal("mark dotted");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(10);
-  expect(c.ops[0].to.y).to.equal(10);
-  expect(c.ops[1].to.x).to.equal(10);
-  expect(c.ops[1].to.y).to.equal(25);
-  c = pattern.parts.test.paths["1_le"];
-  expect(c.attributes.get("class")).to.equal("mark dotted");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(100);
-  expect(c.ops[0].to.y).to.equal(100);
-  expect(c.ops[1].to.x).to.equal(100);
-  expect(c.ops[1].to.y).to.equal(115);
 });
diff --git a/packages/plugin-bundle/tests/grainline.test.js b/packages/plugin-bundle/tests/grainline.test.js
index e1d71d01c4b..b88c419f7fb 100644
--- a/packages/plugin-bundle/tests/grainline.test.js
+++ b/packages/plugin-bundle/tests/grainline.test.js
@@ -1,38 +1,40 @@
-import freesewing from "freesewing";
-import { version } from "../node_modules/@freesewing/plugin-grainline/package.json";
+import freesewing from "@freesewing/core";
+import { version } from "../../plugin-grainline/package.json";
 let expect = require("chai").expect;
 let plugin = require("../dist/index.js");
 
-it("Should set the plugin name:version attribute", () => {
-  let pattern = new freesewing.Pattern().use(plugin);
-  pattern.render();
-  expect(pattern.svg.attributes.get("freesewing:plugin-grainline")).to.equal(
-    version
-  );
-});
-
-it("Should run the default grainline macro", () => {
-  let pattern = new freesewing.Pattern();
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.from = new pattern.Point(10, 20);
-  pattern.parts.test.points.to = new pattern.Point(10, 230);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("grainline", {
-    from: pattern.parts.test.points.from,
-    to: pattern.parts.test.points.to
+describe("plugin-grainline", function() {
+  it("Should set the plugin name:version attribute", () => {
+    let pattern = new freesewing.Pattern().use(plugin);
+    pattern.render();
+    expect(pattern.svg.attributes.get("freesewing:plugin-grainline")).to.equal(
+      version
+    );
+  });
+  
+  it("Should run the default grainline macro", () => {
+    let pattern = new freesewing.Pattern();
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.from = new pattern.Point(10, 20);
+    pattern.parts.test.points.to = new pattern.Point(10, 230);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("grainline", {
+      from: pattern.parts.test.points.from,
+      to: pattern.parts.test.points.to
+    });
+    let c = pattern.parts.test.paths.grainline;
+    expect(c.attributes.get("class")).to.equal("note");
+    expect(c.attributes.get("marker-start")).to.equal("url(#grainlineFrom)");
+    expect(c.attributes.get("marker-end")).to.equal("url(#grainlineTo)");
+    expect(c.attributes.get("data-text")).to.equal("grainline");
+    expect(c.attributes.get("data-text-class")).to.equal("center fill-note");
+    expect(c.ops[0].type).to.equal("move");
+    expect(c.ops[1].type).to.equal("line");
+    expect(c.ops[0].to.x).to.equal(10);
+    expect(c.ops[0].to.y).to.equal(30.5);
+    expect(c.ops[1].to.x).to.equal(10);
+    expect(c.ops[1].to.y).to.equal(219.5);
   });
-  let c = pattern.parts.test.paths.grainline;
-  expect(c.attributes.get("class")).to.equal("note");
-  expect(c.attributes.get("marker-start")).to.equal("url(#grainlineFrom)");
-  expect(c.attributes.get("marker-end")).to.equal("url(#grainlineTo)");
-  expect(c.attributes.get("data-text")).to.equal("grainline");
-  expect(c.attributes.get("data-text-class")).to.equal("center fill-note");
-  expect(c.ops[0].type).to.equal("move");
-  expect(c.ops[1].type).to.equal("line");
-  expect(c.ops[0].to.x).to.equal(10);
-  expect(c.ops[0].to.y).to.equal(30.5);
-  expect(c.ops[1].to.x).to.equal(10);
-  expect(c.ops[1].to.y).to.equal(219.5);
 });
diff --git a/packages/plugin-bundle/tests/round.test.js b/packages/plugin-bundle/tests/round.test.js
index 32915275d76..dbe148b2faf 100644
--- a/packages/plugin-bundle/tests/round.test.js
+++ b/packages/plugin-bundle/tests/round.test.js
@@ -1,12 +1,14 @@
-import freesewing from "freesewing";
-import { version } from "../node_modules/@freesewing/plugin-round/package.json";
+import freesewing from "@freesewing/core";
+import { version } from "../../plugin-round/package.json";
 let expect = require("chai").expect;
 let plugin = require("../dist/index.js");
 
-it("Should set the plugin name:version attribute", () => {
-  let pattern = new freesewing.Pattern().use(plugin);
-  pattern.render();
-  expect(pattern.svg.attributes.get("freesewing:plugin-round")).to.equal(
-    version
-  );
+describe("plugin-round", function() {
+  it("Should set the plugin name:version attribute", () => {
+    let pattern = new freesewing.Pattern().use(plugin);
+    pattern.render();
+    expect(pattern.svg.attributes.get("freesewing:plugin-round")).to.equal(
+      version
+    );
+  });
 });
diff --git a/packages/plugin-bundle/tests/scalebox.test.js b/packages/plugin-bundle/tests/scalebox.test.js
index c6d84a97c7d..4d1486eef14 100644
--- a/packages/plugin-bundle/tests/scalebox.test.js
+++ b/packages/plugin-bundle/tests/scalebox.test.js
@@ -1,184 +1,186 @@
-import freesewing from "freesewing";
-import { version } from "../node_modules/@freesewing/plugin-scalebox/package.json";
+import freesewing from "@freesewing/core";
+import { version } from "../../plugin-scalebox/package.json";
 let expect = require("chai").expect;
 let plugin = require("../dist/index.js");
 
-it("Should set the plugin name:version attribute", () => {
-  let pattern = new freesewing.Pattern().use(plugin);
-  pattern.render();
-  expect(pattern.svg.attributes.get("freesewing:plugin-scalebox")).to.equal(
-    version
-  );
-});
-
-it("Should run the default scalebox macro", () => {
-  let pattern = new freesewing.Pattern();
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.anchor = new pattern.Point(100, 200);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("scalebox", {
-    at: pattern.parts.test.points.anchor
-  });
-  let p = pattern.parts.test.points;
-  expect(p.__scaleboxMetricTopLeft.x).to.equal(50);
-  expect(p.__scaleboxMetricTopLeft.y).to.equal(175);
-  expect(p.__scaleboxMetricTopRight.x).to.equal(150);
-  expect(p.__scaleboxMetricTopRight.y).to.equal(175);
-  expect(p.__scaleboxMetricBottomLeft.x).to.equal(50);
-  expect(p.__scaleboxMetricBottomLeft.y).to.equal(225);
-  expect(p.__scaleboxMetricBottomRight.x).to.equal(150);
-  expect(p.__scaleboxMetricBottomRight.y).to.equal(225);
-  expect(p.__scaleboxImperialTopLeft.x).to.equal(49.2);
-  expect(p.__scaleboxImperialTopLeft.y).to.equal(174.6);
-  expect(p.__scaleboxImperialTopRight.x).to.equal(150.8);
-  expect(p.__scaleboxImperialTopRight.y).to.equal(174.6);
-  expect(p.__scaleboxImperialBottomLeft.x).to.equal(49.2);
-  expect(p.__scaleboxImperialBottomLeft.y).to.equal(225.4);
-  expect(p.__scaleboxImperialBottomRight.x).to.equal(150.8);
-  expect(p.__scaleboxImperialBottomRight.y).to.equal(225.4);
-  expect(p.__scaleboxLead.x).to.equal(55);
-  expect(p.__scaleboxLead.y).to.equal(185);
-  expect(p.__scaleboxTitle.x).to.equal(55);
-  expect(p.__scaleboxTitle.y).to.equal(195);
-  expect(p.__scaleboxText.x).to.equal(55);
-  expect(p.__scaleboxText.y).to.equal(203);
-  expect(p.__scaleboxLink.x).to.equal(55);
-  expect(p.__scaleboxLink.y).to.equal(211);
-  expect(p.__scaleboxMetric.x).to.equal(100);
-  expect(p.__scaleboxMetric.y).to.equal(220);
-  expect(p.__scaleboxImperial.x).to.equal(100);
-  expect(p.__scaleboxImperial.y).to.equal(224);
-  p = pattern.parts.test.paths.__scaleboxMetric;
-  expect(p.attributes.get("style")).to.equal("fill: #FFF; stroke: none;");
-  expect(p.ops[0].type).to.equal("move");
-  expect(p.ops[1].type).to.equal("line");
-  expect(p.ops[2].type).to.equal("line");
-  expect(p.ops[3].type).to.equal("line");
-  expect(p.ops[4].type).to.equal("close");
-  expect(p.ops[0].to.x).to.equal(50);
-  expect(p.ops[0].to.y).to.equal(175);
-  expect(p.ops[1].to.x).to.equal(50);
-  expect(p.ops[1].to.y).to.equal(225);
-  expect(p.ops[2].to.x).to.equal(150);
-  expect(p.ops[2].to.y).to.equal(225);
-  expect(p.ops[3].to.x).to.equal(150);
-  expect(p.ops[3].to.y).to.equal(175);
-  p = pattern.parts.test.paths.__scaleboxImperial;
-  expect(p.attributes.get("style")).to.equal("fill: #000; stroke: none;");
-  expect(p.ops[0].type).to.equal("move");
-  expect(p.ops[1].type).to.equal("line");
-  expect(p.ops[2].type).to.equal("line");
-  expect(p.ops[3].type).to.equal("line");
-  expect(p.ops[4].type).to.equal("close");
-  expect(p.ops[0].to.x).to.equal(49.2);
-  expect(p.ops[0].to.y).to.equal(174.6);
-  expect(p.ops[1].to.x).to.equal(49.2);
-  expect(p.ops[1].to.y).to.equal(225.4);
-  expect(p.ops[2].to.x).to.equal(150.8);
-  expect(p.ops[2].to.y).to.equal(225.4);
-  expect(p.ops[3].to.x).to.equal(150.8);
-  expect(p.ops[3].to.y).to.equal(174.6);
-});
-
-it("Should run the scalebox macro with rotation", () => {
-  let pattern = new freesewing.Pattern();
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.anchor = new pattern.Point(100, 200);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("scalebox", {
-    at: pattern.parts.test.points.anchor,
-    rotate: 90
-  });
-  let p = pattern.parts.test.points;
-  expect(p.__scaleboxMetricTopLeft.x).to.equal(75);
-  expect(p.__scaleboxMetricTopLeft.y).to.equal(250);
-  expect(p.__scaleboxMetricTopRight.x).to.equal(75);
-  expect(p.__scaleboxMetricTopRight.y).to.equal(150);
-  expect(p.__scaleboxMetricBottomLeft.x).to.equal(125);
-  expect(p.__scaleboxMetricBottomLeft.y).to.equal(250);
-  expect(p.__scaleboxMetricBottomRight.x).to.equal(125);
-  expect(p.__scaleboxMetricBottomRight.y).to.equal(150);
-  expect(p.__scaleboxImperialTopLeft.x).to.equal(74.6);
-  expect(p.__scaleboxImperialTopLeft.y).to.equal(250.8);
-  expect(p.__scaleboxImperialTopRight.x).to.equal(74.6);
-  expect(p.__scaleboxImperialTopRight.y).to.equal(149.2);
-  expect(p.__scaleboxImperialBottomLeft.x).to.equal(125.4);
-  expect(p.__scaleboxImperialBottomLeft.y).to.equal(250.8);
-  expect(p.__scaleboxImperialBottomRight.x).to.equal(125.4);
-  expect(p.__scaleboxImperialBottomRight.y).to.equal(149.2);
-  expect(p.__scaleboxLead.x).to.equal(85);
-  expect(p.__scaleboxLead.y).to.equal(245);
-  expect(p.__scaleboxTitle.x).to.equal(95);
-  expect(p.__scaleboxTitle.y).to.equal(245);
-  expect(p.__scaleboxText.x).to.equal(103);
-  expect(p.__scaleboxText.y).to.equal(245);
-  expect(p.__scaleboxLink.x).to.equal(111);
-  expect(p.__scaleboxLink.y).to.equal(245);
-  expect(p.__scaleboxMetric.x).to.equal(120);
-  expect(p.__scaleboxMetric.y).to.equal(200);
-  expect(p.__scaleboxImperial.x).to.equal(124);
-  expect(p.__scaleboxImperial.y).to.equal(200);
-});
-
-it("Should run the scalebox macro with default text", () => {
-  let pattern = new freesewing.Pattern({
-    name: "unitTest",
-    version: 99
-  });
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.anchor = new pattern.Point(100, 200);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("scalebox", {
-    at: pattern.parts.test.points.anchor
-  });
-  let p = pattern.parts.test.points.__scaleboxLead.attributes;
-  expect(p.get("data-text")).to.equal("freesewing");
-  expect(p.get("data-text-class")).to.equal("text-sm");
-  p = pattern.parts.test.points.__scaleboxTitle.attributes;
-  expect(p.get("data-text")).to.equal("unitTest v99");
-  expect(p.get("data-text-class")).to.equal("text-lg");
-  p = pattern.parts.test.points.__scaleboxText.attributes;
-  expect(p.get("data-text-class")).to.equal("text-xs");
-  expect(p.get("data-text-lineheight")).to.equal("4");
-  expect(p.list["data-text"][0]).to.equal(
-    "freesewingIsMadeByJoostDeCockAndContributors"
-  );
-  expect(p.list["data-text"][1]).to.equal("\n");
-  expect(p.list["data-text"][2]).to.equal(
-    "withTheFinancialSupportOfOurPatrons"
-  );
-});
-
-it("Should run the scalebox macro with custom text", () => {
-  let pattern = new freesewing.Pattern({
-    name: "unitTest",
-    version: 99
-  });
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.anchor = new pattern.Point(100, 200);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("scalebox", {
-    at: pattern.parts.test.points.anchor,
-    lead: "theLead",
-    title: "theTitle",
-    text: "theText"
-  });
-  let p = pattern.parts.test.points.__scaleboxLead.attributes;
-  expect(p.get("data-text")).to.equal("theLead");
-  expect(p.get("data-text-class")).to.equal("text-sm");
-  p = pattern.parts.test.points.__scaleboxTitle.attributes;
-  expect(p.get("data-text")).to.equal("theTitle");
-  expect(p.get("data-text-class")).to.equal("text-lg");
-  p = pattern.parts.test.points.__scaleboxText.attributes;
-  expect(p.get("data-text")).to.equal("theText");
-  expect(p.get("data-text-class")).to.equal("text-xs");
-  expect(p.get("data-text-lineheight")).to.equal("4");
+describe("plugin-scalebox", function() {
+  it("Should set the plugin name:version attribute", () => {
+    let pattern = new freesewing.Pattern().use(plugin);
+    pattern.render();
+    expect(pattern.svg.attributes.get("freesewing:plugin-scalebox")).to.equal(
+      version
+    );
+  });
+  
+  it("Should run the default scalebox macro", () => {
+    let pattern = new freesewing.Pattern();
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.anchor = new pattern.Point(100, 200);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("scalebox", {
+      at: pattern.parts.test.points.anchor
+    });
+    let p = pattern.parts.test.points;
+    expect(p.__scaleboxMetricTopLeft.x).to.equal(50);
+    expect(p.__scaleboxMetricTopLeft.y).to.equal(175);
+    expect(p.__scaleboxMetricTopRight.x).to.equal(150);
+    expect(p.__scaleboxMetricTopRight.y).to.equal(175);
+    expect(p.__scaleboxMetricBottomLeft.x).to.equal(50);
+    expect(p.__scaleboxMetricBottomLeft.y).to.equal(225);
+    expect(p.__scaleboxMetricBottomRight.x).to.equal(150);
+    expect(p.__scaleboxMetricBottomRight.y).to.equal(225);
+    expect(p.__scaleboxImperialTopLeft.x).to.equal(49.2);
+    expect(p.__scaleboxImperialTopLeft.y).to.equal(174.6);
+    expect(p.__scaleboxImperialTopRight.x).to.equal(150.8);
+    expect(p.__scaleboxImperialTopRight.y).to.equal(174.6);
+    expect(p.__scaleboxImperialBottomLeft.x).to.equal(49.2);
+    expect(p.__scaleboxImperialBottomLeft.y).to.equal(225.4);
+    expect(p.__scaleboxImperialBottomRight.x).to.equal(150.8);
+    expect(p.__scaleboxImperialBottomRight.y).to.equal(225.4);
+    expect(p.__scaleboxLead.x).to.equal(55);
+    expect(p.__scaleboxLead.y).to.equal(185);
+    expect(p.__scaleboxTitle.x).to.equal(55);
+    expect(p.__scaleboxTitle.y).to.equal(195);
+    expect(p.__scaleboxText.x).to.equal(55);
+    expect(p.__scaleboxText.y).to.equal(203);
+    expect(p.__scaleboxLink.x).to.equal(55);
+    expect(p.__scaleboxLink.y).to.equal(211);
+    expect(p.__scaleboxMetric.x).to.equal(100);
+    expect(p.__scaleboxMetric.y).to.equal(220);
+    expect(p.__scaleboxImperial.x).to.equal(100);
+    expect(p.__scaleboxImperial.y).to.equal(224);
+    p = pattern.parts.test.paths.__scaleboxMetric;
+    expect(p.attributes.get("style")).to.equal("fill: #FFF; stroke: none;");
+    expect(p.ops[0].type).to.equal("move");
+    expect(p.ops[1].type).to.equal("line");
+    expect(p.ops[2].type).to.equal("line");
+    expect(p.ops[3].type).to.equal("line");
+    expect(p.ops[4].type).to.equal("close");
+    expect(p.ops[0].to.x).to.equal(50);
+    expect(p.ops[0].to.y).to.equal(175);
+    expect(p.ops[1].to.x).to.equal(50);
+    expect(p.ops[1].to.y).to.equal(225);
+    expect(p.ops[2].to.x).to.equal(150);
+    expect(p.ops[2].to.y).to.equal(225);
+    expect(p.ops[3].to.x).to.equal(150);
+    expect(p.ops[3].to.y).to.equal(175);
+    p = pattern.parts.test.paths.__scaleboxImperial;
+    expect(p.attributes.get("style")).to.equal("fill: #000; stroke: none;");
+    expect(p.ops[0].type).to.equal("move");
+    expect(p.ops[1].type).to.equal("line");
+    expect(p.ops[2].type).to.equal("line");
+    expect(p.ops[3].type).to.equal("line");
+    expect(p.ops[4].type).to.equal("close");
+    expect(p.ops[0].to.x).to.equal(49.2);
+    expect(p.ops[0].to.y).to.equal(174.6);
+    expect(p.ops[1].to.x).to.equal(49.2);
+    expect(p.ops[1].to.y).to.equal(225.4);
+    expect(p.ops[2].to.x).to.equal(150.8);
+    expect(p.ops[2].to.y).to.equal(225.4);
+    expect(p.ops[3].to.x).to.equal(150.8);
+    expect(p.ops[3].to.y).to.equal(174.6);
+  });
+  
+  it("Should run the scalebox macro with rotation", () => {
+    let pattern = new freesewing.Pattern();
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.anchor = new pattern.Point(100, 200);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("scalebox", {
+      at: pattern.parts.test.points.anchor,
+      rotate: 90
+    });
+    let p = pattern.parts.test.points;
+    expect(p.__scaleboxMetricTopLeft.x).to.equal(75);
+    expect(p.__scaleboxMetricTopLeft.y).to.equal(250);
+    expect(p.__scaleboxMetricTopRight.x).to.equal(75);
+    expect(p.__scaleboxMetricTopRight.y).to.equal(150);
+    expect(p.__scaleboxMetricBottomLeft.x).to.equal(125);
+    expect(p.__scaleboxMetricBottomLeft.y).to.equal(250);
+    expect(p.__scaleboxMetricBottomRight.x).to.equal(125);
+    expect(p.__scaleboxMetricBottomRight.y).to.equal(150);
+    expect(p.__scaleboxImperialTopLeft.x).to.equal(74.6);
+    expect(p.__scaleboxImperialTopLeft.y).to.equal(250.8);
+    expect(p.__scaleboxImperialTopRight.x).to.equal(74.6);
+    expect(p.__scaleboxImperialTopRight.y).to.equal(149.2);
+    expect(p.__scaleboxImperialBottomLeft.x).to.equal(125.4);
+    expect(p.__scaleboxImperialBottomLeft.y).to.equal(250.8);
+    expect(p.__scaleboxImperialBottomRight.x).to.equal(125.4);
+    expect(p.__scaleboxImperialBottomRight.y).to.equal(149.2);
+    expect(p.__scaleboxLead.x).to.equal(85);
+    expect(p.__scaleboxLead.y).to.equal(245);
+    expect(p.__scaleboxTitle.x).to.equal(95);
+    expect(p.__scaleboxTitle.y).to.equal(245);
+    expect(p.__scaleboxText.x).to.equal(103);
+    expect(p.__scaleboxText.y).to.equal(245);
+    expect(p.__scaleboxLink.x).to.equal(111);
+    expect(p.__scaleboxLink.y).to.equal(245);
+    expect(p.__scaleboxMetric.x).to.equal(120);
+    expect(p.__scaleboxMetric.y).to.equal(200);
+    expect(p.__scaleboxImperial.x).to.equal(124);
+    expect(p.__scaleboxImperial.y).to.equal(200);
+  });
+  
+  it("Should run the scalebox macro with default text", () => {
+    let pattern = new freesewing.Pattern({
+      name: "unitTest",
+      version: 99
+    });
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.anchor = new pattern.Point(100, 200);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("scalebox", {
+      at: pattern.parts.test.points.anchor
+    });
+    let p = pattern.parts.test.points.__scaleboxLead.attributes;
+    expect(p.get("data-text")).to.equal("freesewing");
+    expect(p.get("data-text-class")).to.equal("text-sm");
+    p = pattern.parts.test.points.__scaleboxTitle.attributes;
+    expect(p.get("data-text")).to.equal("unitTest v99");
+    expect(p.get("data-text-class")).to.equal("text-lg");
+    p = pattern.parts.test.points.__scaleboxText.attributes;
+    expect(p.get("data-text-class")).to.equal("text-xs");
+    expect(p.get("data-text-lineheight")).to.equal("4");
+    expect(p.list["data-text"][0]).to.equal(
+      "freesewingIsMadeByJoostDeCockAndContributors"
+    );
+    expect(p.list["data-text"][1]).to.equal("\n");
+    expect(p.list["data-text"][2]).to.equal(
+      "withTheFinancialSupportOfOurPatrons"
+    );
+  });
+  
+  it("Should run the scalebox macro with custom text", () => {
+    let pattern = new freesewing.Pattern({
+      name: "unitTest",
+      version: 99
+    });
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.anchor = new pattern.Point(100, 200);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("scalebox", {
+      at: pattern.parts.test.points.anchor,
+      lead: "theLead",
+      title: "theTitle",
+      text: "theText"
+    });
+    let p = pattern.parts.test.points.__scaleboxLead.attributes;
+    expect(p.get("data-text")).to.equal("theLead");
+    expect(p.get("data-text-class")).to.equal("text-sm");
+    p = pattern.parts.test.points.__scaleboxTitle.attributes;
+    expect(p.get("data-text")).to.equal("theTitle");
+    expect(p.get("data-text-class")).to.equal("text-lg");
+    p = pattern.parts.test.points.__scaleboxText.attributes;
+    expect(p.get("data-text")).to.equal("theText");
+    expect(p.get("data-text-class")).to.equal("text-xs");
+    expect(p.get("data-text-lineheight")).to.equal("4");
+  });
 });
diff --git a/packages/plugin-bundle/tests/sprinkle.test.js b/packages/plugin-bundle/tests/sprinkle.test.js
index d8c16ad24af..7979dfc97a6 100644
--- a/packages/plugin-bundle/tests/sprinkle.test.js
+++ b/packages/plugin-bundle/tests/sprinkle.test.js
@@ -1,12 +1,14 @@
-import freesewing from "freesewing";
-import { version } from "../node_modules/@freesewing/plugin-sprinkle/package.json";
+import freesewing from "@freesewing/core";
+import { version } from "../../plugin-sprinkle/package.json";
 let expect = require("chai").expect;
 let plugin = require("../dist/index.js");
 
-it("Should set the plugin name:version attribute", () => {
-  let pattern = new freesewing.Pattern().use(plugin);
-  pattern.render();
-  expect(pattern.svg.attributes.get("freesewing:plugin-sprinkle")).to.equal(
-    version
-  );
+describe('plugin-sprinkle', function() {
+  it("Should set the plugin name:version attribute", () => {
+    let pattern = new freesewing.Pattern().use(plugin);
+    pattern.render();
+    expect(pattern.svg.attributes.get("freesewing:plugin-sprinkle")).to.equal(
+      version
+    );
+  });
 });
diff --git a/packages/plugin-bundle/tests/title.test.js b/packages/plugin-bundle/tests/title.test.js
index 5c666300c9c..922959b7bc5 100644
--- a/packages/plugin-bundle/tests/title.test.js
+++ b/packages/plugin-bundle/tests/title.test.js
@@ -1,117 +1,119 @@
-import freesewing from "freesewing";
-import { version } from "../node_modules/@freesewing/plugin-title/package.json";
+import freesewing from "@freesewing/core";
+import { version } from "../../plugin-title/package.json";
 let expect = require("chai").expect;
 let plugin = require("../dist/index.js");
 
-it("Should set the plugin name:version attribute", () => {
-  let pattern = new freesewing.Pattern();
-  pattern.use(plugin);
-  pattern.render();
-  expect(pattern.svg.attributes.get("freesewing:plugin-title")).to.equal(
-    version
-  );
-});
-
-it("Should run the title macro", () => {
-  let pattern = new freesewing.Pattern({ name: "testPattern", version: 99 });
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.anchor = new pattern.Point(-12, -34);
-  let { macro } = pattern.parts.test.shorthand();
-  macro("title", {
-    at: pattern.parts.test.points.anchor,
-    nr: 3,
-    title: "unitTest"
+describe('plugin-title', function () {
+  it("Should set the plugin name:version attribute", () => {
+    let pattern = new freesewing.Pattern();
+    pattern.use(plugin);
+    pattern.render();
+    expect(pattern.svg.attributes.get("freesewing:plugin-title")).to.equal(
+      version
+    );
   });
-  pattern.render();
-  let p = pattern.parts.test.points.__titleNr;
-  expect(p.x).to.equal(-12);
-  expect(p.y).to.equal(-34);
-  expect(p.attributes.get("data-text")).to.equal("3");
-  expect(p.attributes.get("data-text-class")).to.equal(
-    "title-nr note fill-note"
-  );
-  expect(p.attributes.get("data-text-x")).to.equal("-12");
-  expect(p.attributes.get("data-text-y")).to.equal("-34");
-  p = pattern.parts.test.points.__titleName;
-  expect(p.attributes.get("data-text")).to.equal("unitTest");
-  expect(p.attributes.get("data-text-class")).to.equal("title-name");
-  expect(p.attributes.get("data-text-x")).to.equal("-12");
-  expect(p.attributes.get("data-text-y")).to.equal("-21");
-  p = pattern.parts.test.points.__titlePattern;
-  expect(p.attributes.get("data-text")).to.equal("testPattern v99");
-  expect(p.attributes.get("data-text-class")).to.equal(
-    "title-pattern fill-note"
-  );
-  expect(p.attributes.get("data-text-x")).to.equal("-12");
-  expect(p.attributes.get("data-text-y")).to.equal("-14");
-});
 
-it("Should run the title macro with append flag", () => {
-  let pattern = new freesewing.Pattern({ name: "testPattern", version: 99 });
-  pattern.use(plugin);
-  pattern.draft = function() {};
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.anchor = new pattern.Point(-12, -34).attr(
-    "data-text",
-    "#"
-  );
-  let { macro } = pattern.parts.test.shorthand();
-  macro("title", {
-    at: pattern.parts.test.points.anchor,
-    nr: 3,
-    title: "unitTest",
-    append: true
+  it("Should run the title macro", () => {
+    let pattern = new freesewing.Pattern({ name: "testPattern", version: 99 });
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.anchor = new pattern.Point(-12, -34);
+    let { macro } = pattern.parts.test.shorthand();
+    macro("title", {
+      at: pattern.parts.test.points.anchor,
+      nr: 3,
+      title: "unitTest"
+    });
+    pattern.render();
+    let p = pattern.parts.test.points.__titleNr;
+    expect(p.x).to.equal(-12);
+    expect(p.y).to.equal(-34);
+    expect(p.attributes.get("data-text")).to.equal("3");
+    expect(p.attributes.get("data-text-class")).to.equal(
+      "title-nr note fill-note"
+    );
+    expect(p.attributes.get("data-text-x")).to.equal("-12");
+    expect(p.attributes.get("data-text-y")).to.equal("-34");
+    p = pattern.parts.test.points.__titleName;
+    expect(p.attributes.get("data-text")).to.equal("unitTest");
+    expect(p.attributes.get("data-text-class")).to.equal("title-name");
+    expect(p.attributes.get("data-text-x")).to.equal("-12");
+    expect(p.attributes.get("data-text-y")).to.equal("-21");
+    p = pattern.parts.test.points.__titlePattern;
+    expect(p.attributes.get("data-text")).to.equal("testPattern v99");
+    expect(p.attributes.get("data-text-class")).to.equal(
+      "title-pattern fill-note"
+    );
+    expect(p.attributes.get("data-text-x")).to.equal("-12");
+    expect(p.attributes.get("data-text-y")).to.equal("-14");
   });
-  pattern.render();
-  let p = pattern.parts.test.points.__titleNr;
-  expect(p.x).to.equal(-12);
-  expect(p.y).to.equal(-34);
-  expect(p.attributes.get("data-text")).to.equal("# 3");
-  expect(p.attributes.get("data-text-class")).to.equal(
-    "title-nr note fill-note"
-  );
-  expect(p.attributes.get("data-text-x")).to.equal("-12");
-  expect(p.attributes.get("data-text-y")).to.equal("-34");
-});
 
-it("Should run the title macro with point prefix", () => {
-  let pattern = new freesewing.Pattern({ name: "testPattern", version: 99 });
-  pattern.draft = function() {};
-  pattern.use(plugin);
-  pattern.parts.test = new pattern.Part();
-  pattern.parts.test.points.anchor = new pattern.Point(-12, -34).attr(
-    "data-text",
-    "#"
-  );
-  let { macro } = pattern.parts.test.shorthand();
-  macro("title", {
-    at: pattern.parts.test.points.anchor,
-    nr: 3,
-    title: "unitTest",
-    prefix: "foo"
+  it("Should run the title macro with append flag", () => {
+    let pattern = new freesewing.Pattern({ name: "testPattern", version: 99 });
+    pattern.use(plugin);
+    pattern.draft = function() {};
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.anchor = new pattern.Point(-12, -34).attr(
+      "data-text",
+      "#"
+    );
+    let { macro } = pattern.parts.test.shorthand();
+    macro("title", {
+      at: pattern.parts.test.points.anchor,
+      nr: 3,
+      title: "unitTest",
+      append: true
+    });
+    pattern.render();
+    let p = pattern.parts.test.points.__titleNr;
+    expect(p.x).to.equal(-12);
+    expect(p.y).to.equal(-34);
+    expect(p.attributes.get("data-text")).to.equal("# 3");
+    expect(p.attributes.get("data-text-class")).to.equal(
+      "title-nr note fill-note"
+    );
+    expect(p.attributes.get("data-text-x")).to.equal("-12");
+    expect(p.attributes.get("data-text-y")).to.equal("-34");
+  });
+
+  it("Should run the title macro with point prefix", () => {
+    let pattern = new freesewing.Pattern({ name: "testPattern", version: 99 });
+    pattern.draft = function() {};
+    pattern.use(plugin);
+    pattern.parts.test = new pattern.Part();
+    pattern.parts.test.points.anchor = new pattern.Point(-12, -34).attr(
+      "data-text",
+      "#"
+    );
+    let { macro } = pattern.parts.test.shorthand();
+    macro("title", {
+      at: pattern.parts.test.points.anchor,
+      nr: 3,
+      title: "unitTest",
+      prefix: "foo"
+    });
+    pattern.render();
+    let p = pattern.parts.test.points._foo_titleNr;
+    expect(p.x).to.equal(-12);
+    expect(p.y).to.equal(-34);
+    expect(p.attributes.get("data-text")).to.equal("3");
+    expect(p.attributes.get("data-text-class")).to.equal(
+      "title-nr note fill-note"
+    );
+    expect(p.attributes.get("data-text-x")).to.equal("-12");
+    expect(p.attributes.get("data-text-y")).to.equal("-34");
+    p = pattern.parts.test.points._foo_titleName;
+    expect(p.attributes.get("data-text")).to.equal("unitTest");
+    expect(p.attributes.get("data-text-class")).to.equal("title-name");
+    expect(p.attributes.get("data-text-x")).to.equal("-12");
+    expect(p.attributes.get("data-text-y")).to.equal("-21");
+    p = pattern.parts.test.points._foo_titlePattern;
+    expect(p.attributes.get("data-text")).to.equal("testPattern v99");
+    expect(p.attributes.get("data-text-class")).to.equal(
+      "title-pattern fill-note"
+    );
+    expect(p.attributes.get("data-text-x")).to.equal("-12");
+    expect(p.attributes.get("data-text-y")).to.equal("-14");
   });
-  pattern.render();
-  let p = pattern.parts.test.points._foo_titleNr;
-  expect(p.x).to.equal(-12);
-  expect(p.y).to.equal(-34);
-  expect(p.attributes.get("data-text")).to.equal("3");
-  expect(p.attributes.get("data-text-class")).to.equal(
-    "title-nr note fill-note"
-  );
-  expect(p.attributes.get("data-text-x")).to.equal("-12");
-  expect(p.attributes.get("data-text-y")).to.equal("-34");
-  p = pattern.parts.test.points._foo_titleName;
-  expect(p.attributes.get("data-text")).to.equal("unitTest");
-  expect(p.attributes.get("data-text-class")).to.equal("title-name");
-  expect(p.attributes.get("data-text-x")).to.equal("-12");
-  expect(p.attributes.get("data-text-y")).to.equal("-21");
-  p = pattern.parts.test.points._foo_titlePattern;
-  expect(p.attributes.get("data-text")).to.equal("testPattern v99");
-  expect(p.attributes.get("data-text-class")).to.equal(
-    "title-pattern fill-note"
-  );
-  expect(p.attributes.get("data-text-x")).to.equal("-12");
-  expect(p.attributes.get("data-text-y")).to.equal("-14");
 });