Refactor to use private methods

.gitignore

@@ -97,4 +97,4 @@ typings/
 gerber/
 hello.txt
 test/tmp/*
-test/archiveTest
+test/arduino/*

dist/index.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImageGenerator = void 0;
 //Modules
-// const AdmZip = require('adm-zip');
 const adm_zip_1 = __importDefault(require("adm-zip"));
 const fs_extra_1 = require("fs-extra");
 const path_1 = __importDefault(require("path"));
@@ -20,47 +19,10 @@ class ImageGenerator {
         this.imgConfig = imgConfig;
         this.layerNames = layerNames;
         //Ensure folders exist
-        if (!(0, node_fs_1.existsSync)(folderConfig.tmpDir))
+        if (!validFolder(folderConfig.tmpDir, true))
-            throw new Error('Temp dir does not exist');
+            throw new Error('Temp directory is invalid');
-        if (!(0, node_fs_1.existsSync)(folderConfig.imgDir))
+        if (!validFolder(folderConfig.imgDir, true))
-            throw new Error('Image dir does not exist');
+            throw new Error('Image directory is invalid');
-        //Check folder permissions
-        (0, node_fs_1.accessSync)(folderConfig.tmpDir, node_fs_1.constants.R_OK | node_fs_1.constants.W_OK);
-        (0, node_fs_1.accessSync)(folderConfig.imgDir, node_fs_1.constants.R_OK | node_fs_1.constants.W_OK);
-    }
-    /**
-     * Extracts the passed in zip file
-  
-     */
-    extractArchive(fileName, tmpDir) {
-        // Check archive exists
-        if (!(0, node_fs_1.existsSync)(fileName)) {
-            throw Error('Archive does not exist.');
-        }
-        //Check temp folder exists
-        if (!(0, node_fs_1.existsSync)(tmpDir)) {
-            throw Error('Temporary folder does not exist.');
-        }
-        const zip = new adm_zip_1.default(fileName);
-        zip.extractAllTo(path_1.default.join(tmpDir, 'archive'));
-        return zip.getEntries().length;
-    }
-    //Test archive
-    testArchive(fileName, tmpDir) {
-        // Check archive exists
-        try {
-            if (!(0, node_fs_1.existsSync)(fileName)) {
-                throw Error('Archive does not exist.');
-            }
-            if (!(0, node_fs_1.existsSync)(tmpDir)) {
-                throw Error('Temporary folder does not exist.');
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-        const zip = new adm_zip_1.default(fileName);
-        return zip.getEntries().length;
     }
     //Layer promise
     getLayers(dir, layerNames) {
@@ -132,7 +94,8 @@ class ImageGenerator {
             if (!this.layerNames) {
                 throw new Error('You must supply an array of layer names.');
             }
-            this.extractArchive(gerber, this.folderConfig.tmpDir);
+            //Extract the passed in zip file
+            extractArchive(gerber, this.folderConfig.tmpDir);
             this.getLayers(path_1.default.join(this.folderConfig.tmpDir, 'archive'), this.layerNames)
                 .then(pcb_stackup_1.default)
                 .then((stackup) => {
@@ -168,7 +131,7 @@ class ImageGenerator {
             throw Error('Output folder does not exist.');
         }
         return new Promise((resolve, reject) => {
-            this.extractArchive(gerber, this.folderConfig.tmpDir);
+            extractArchive(gerber, this.folderConfig.tmpDir);
             if (!this.layerNames)
                 throw new Error('No layers provided');
             this.getLayers(path_1.default.join(this.folderConfig.tmpDir, 'archive'), this.layerNames)
@@ -196,3 +159,38 @@ class ImageGenerator {
     }
 }
 exports.ImageGenerator = ImageGenerator;
+//File methods
+//Check that a folder exists and is writeable
+function validFolder(dir, checkPerms) {
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        throw Error('Folder does not exist.');
+    }
+    //Check folder permissions, will throw error if not readable or writeable
+    if (checkPerms) {
+        (0, node_fs_1.accessSync)(dir, node_fs_1.constants.R_OK | node_fs_1.constants.W_OK);
+        (0, node_fs_1.accessSync)(dir, node_fs_1.constants.R_OK | node_fs_1.constants.W_OK);
+    }
+    //All checks passed
+    return true;
+}
+function extractArchive(fileName, outputDir) {
+    //Check archive exists
+    if (!(0, node_fs_1.existsSync)(fileName)) {
+        throw Error('Archive does not exist.');
+    }
+    //Check output dir is valid
+    if (!validFolder(outputDir, true))
+        throw new Error('Output directory is not valid');
+    //Attempt to extract archive
+    const zip = new adm_zip_1.default(fileName);
+    try {
+        zip.extractAllTo(path_1.default.join(outputDir, 'archive'));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(error.message);
+            return 0;
+        }
+    }
+    return zip.getEntries().length;
+}

src/index.ts

@@ -1,133 +1,44 @@
 //Modules
-// const AdmZip = require('adm-zip');
 import AdmZip from 'adm-zip';
 import { emptyDirSync, ensureDirSync } from 'fs-extra';
 import path from 'path';
 import pcbStackup from 'pcb-stackup';
 import sharp from 'sharp';
 import { Readable } from 'node:stream';
-import { existsSync, accessSync, createReadStream, constants } from 'node:fs';
+import { existsSync, createReadStream, accessSync, constants } from 'node:fs';
 
 //Class definition
-export class ImageGenerator implements ZipExtractor, LayerGenerator {
+export class ImageGenerator {
   constructor(
     public folderConfig: FolderConfig,
     public imgConfig: ImageConfig,
-    public layerNames?: string[],
+    public layerNames: string[],
   ) {
     //Ensure folders exist
-    if (!existsSync(folderConfig.tmpDir))
+    if (!this.validFolder(folderConfig.tmpDir, true))
-      throw new Error('Temp dir does not exist');
+      throw new Error('Temp directory is invalid');
 
-    if (!existsSync(folderConfig.imgDir))
+    if (!this.validFolder(folderConfig.imgDir, true))
-      throw new Error('Image dir does not exist');
+      throw new Error('Image directory is invalid');
-
-    //Check folder permissions
-    accessSync(folderConfig.tmpDir, constants.R_OK | constants.W_OK);
-    accessSync(folderConfig.imgDir, constants.R_OK | constants.W_OK);
   }
 
-  /**
+  //Take an archive containing gerber files, config object, temporary dir
-   * Extracts the passed in zip file
+  //and output dir and create a PNG image from the gerber in the output dir
-
+  public gerberToImage(gerber: string) {
-   */
+    //Check gerber archive exists
-  public extractArchive(fileName: string, tmpDir: string): number {
+    if (!existsSync(gerber)) {
-    // Check archive exists
-    if (!existsSync(fileName)) {
       throw Error('Archive does not exist.');
     }
-    //Check temp folder exists
-    if (!existsSync(tmpDir)) {
-      throw Error('Temporary folder does not exist.');
-    }
 
-    const zip = new AdmZip(fileName);
-    zip.extractAllTo(path.join(tmpDir, 'archive'));
-
-    return zip.getEntries().length;
-  }
-
-  //Test archive
-  public testArchive(fileName: string, tmpDir: string): number {
-    // Check archive exists
-    try {
-      if (!existsSync(fileName)) {
-        throw Error('Archive does not exist.');
-      }
-      if (!existsSync(tmpDir)) {
-        throw Error('Temporary folder does not exist.');
-      }
-    } catch (e: unknown) {
-      console.error(e);
-    }
-    const zip = new AdmZip(fileName);
-    return zip.getEntries().length;
-  }
-
-  //Layer promise
-  public getLayers(dir: string, layerNames: string[]): Promise<Layers[]> {
-    //Check correct number of layers and folder exists
-    layerNames.forEach((layerName) => {
-      if (!existsSync(path.join(dir, layerName))) {
-        throw `Missing layer: ${layerName}`;
-      }
-    });
-    if (!existsSync(dir)) {
-      throw new Error('Folder not there');
-    }
-    //Return layer promise
-    const layersPromise = new Promise<Layers[]>(function (resolve, reject) {
-      const layers: Layers[] = layerNames.map((layerName: string) => ({
-        filename: layerName,
-        gerber: createReadStream(path.join(dir, layerName)),
-      }));
-      if (layers.length === layerNames.length) {
-        resolve(layers);
-      } else {
-        reject('Invalid layer count');
-      }
-    });
-    return layersPromise;
-  }
-
-  //Clean up the archive folder in the specified directory
-  public static cleanupFiles(dir: string): void {
-    try {
-      const folder = path.join(dir, 'archive');
-      emptyDirSync(folder);
-    } catch (error: unknown) {
-      if (error instanceof Error) {
-        console.error(error.message);
-      }
-    }
-  }
-
-  //  * Take an archive containing gerber files, config object, temporary dir
-  //  * and output dir and create a PNG image from the gerber in the output dir
-  //  * @param {string} gerber Path to an archive file containing gerber
-  //  * @returns {Promise.<string>} Promise to return path to image
-
-  public gerberToImage(gerber: string) {
     // Create output dir if it doesn't exist
     try {
       ensureDirSync(this.folderConfig.imgDir);
     } catch (error) {
       if (error instanceof Error) {
-        console.error(error.message);
+        throw error;
       }
     }
 
-    // Check temp and output dirs exist
-    if (!existsSync(gerber)) {
-      throw Error('Archive does not exist.');
-    }
-    if (!existsSync(this.folderConfig.tmpDir)) {
-      throw Error('Temporary folder does not exist.');
-    }
-    if (!existsSync(this.folderConfig.imgDir)) {
-      throw Error('Output folder does not exist.');
-    }
-
     // Set filenames
     //Use the filename of the gerber zip to determine the output png filename
     const imageName = path.basename(gerber, '.zip');
@@ -135,9 +46,19 @@ export class ImageGenerator implements ZipExtractor, LayerGenerator {
 
     return new Promise((resolve, reject) => {
       if (!this.layerNames) {
-        throw new Error('You must supply an array of layer names.');
+        reject('You must supply an array of layer names.');
       }
+      //Extract the passed in zip file
       this.extractArchive(gerber, this.folderConfig.tmpDir);
+      //Check all layers present
+      this.layerNames.forEach((layerName) => {
+        if (
+          !existsSync(path.join(this.folderConfig.tmpDir, 'archive', layerName))
+        ) {
+          this.cleanupFiles(this.folderConfig.tmpDir);
+          reject(`Missing layer: ${layerName}`);
+        }
+      });
       this.getLayers(
         path.join(this.folderConfig.tmpDir, 'archive'),
         this.layerNames,
@@ -152,11 +73,11 @@ export class ImageGenerator implements ZipExtractor, LayerGenerator {
             .toFile(destFile);
         })
         .then(() => {
-          ImageGenerator.cleanupFiles(this.folderConfig.tmpDir);
+          this.cleanupFiles(this.folderConfig.tmpDir);
           resolve(destFile);
         })
         .catch((e) => {
-          ImageGenerator.cleanupFiles(this.folderConfig.tmpDir);
+          this.cleanupFiles(this.folderConfig.tmpDir);
           reject(new Error(e));
         });
     });
@@ -167,20 +88,23 @@ export class ImageGenerator implements ZipExtractor, LayerGenerator {
    * a PNG image from the gerber */
 
   gerberToStream(gerber: string) {
-    // Check temp and output dirs exist
+    // Check gerber archive exists
     if (!existsSync(gerber)) {
       throw Error('Archive does not exist.');
     }
-    if (!existsSync(this.folderConfig.tmpDir)) {
-      throw Error('Temporary folder does not exist.');
-    }
-    if (!existsSync(this.folderConfig.imgDir)) {
-      throw Error('Output folder does not exist.');
-    }
 
     return new Promise((resolve, reject) => {
       this.extractArchive(gerber, this.folderConfig.tmpDir);
       if (!this.layerNames) throw new Error('No layers provided');
+      //Check all layers present
+      this.layerNames.forEach((layerName) => {
+        if (
+          !existsSync(path.join(this.folderConfig.tmpDir, 'archive', layerName))
+        ) {
+          this.cleanupFiles(this.folderConfig.tmpDir);
+          reject(`Missing layer: ${layerName}`);
+        }
+      });
       this.getLayers(
         path.join(this.folderConfig.tmpDir, 'archive'),
         this.layerNames,
@@ -194,7 +118,7 @@ export class ImageGenerator implements ZipExtractor, LayerGenerator {
             .png({ compressionLevel: this.imgConfig.compLevel })
             .toBuffer()
             .then((buffer) => {
-              ImageGenerator.cleanupFiles(this.folderConfig.tmpDir);
+              this.cleanupFiles(this.folderConfig.tmpDir);
               const stream = new Readable();
               stream.push(buffer);
               stream.push(null);
@@ -202,9 +126,94 @@ export class ImageGenerator implements ZipExtractor, LayerGenerator {
             });
         })
         .catch((e) => {
-          ImageGenerator.cleanupFiles(this.folderConfig.tmpDir);
+          this.cleanupFiles(this.folderConfig.tmpDir);
           reject(new Error(e));
         });
     });
   }
+
+  //Layer methods
+  //Returns promise that resolves to array of Layers
+  private getLayers(dir: string, layerNames: string[]): Promise<Layers[]> {
+    //Check correct number of layers and folder exists
+    // try {
+    //   layerNames.forEach((layerName) => {
+    //     if (!existsSync(path.join(dir, layerName))) {
+    //       this.cleanupFiles(dir);
+    //       throw new Error(`Missing layer: ${layerName}`);
+    //     }
+    //   });
+    // } catch (error: unknown) {
+    //   if (error instanceof Error) {
+    //     {
+    //       console.error(error.message);
+    //     }
+    //   }
+    // }
+
+    //Return layer promise
+    const layersPromise = new Promise<Layers[]>(function (resolve, reject) {
+      const layers: Layers[] = layerNames.map((layerName: string) => ({
+        filename: layerName,
+        gerber: createReadStream(path.join(dir, layerName)),
+      }));
+      if (layers.length === layerNames.length) {
+        resolve(layers);
+      } else {
+        reject(new Error('Invalid layer count'));
+      }
+    });
+    return layersPromise;
+  }
+
+  //File methods
+  //Check that a folder exists and is writeable
+  private validFolder(dir: string, checkPerms?: boolean): boolean {
+    if (!existsSync(dir)) {
+      throw Error('Folder does not exist.');
+    }
+    //Check folder permissions, will throw error if not readable or writeable
+    if (checkPerms) {
+      accessSync(dir, constants.R_OK | constants.W_OK);
+      accessSync(dir, constants.R_OK | constants.W_OK);
+    }
+
+    //All checks passed
+    return true;
+  }
+
+  private extractArchive(fileName: string, outputDir: string): number {
+    //Check archive exists
+    if (!existsSync(fileName)) {
+      throw Error('Archive does not exist.');
+    }
+
+    //Check output dir is valid
+    if (!this.validFolder(outputDir, true))
+      throw new Error('Output directory is not valid');
+
+    //Attempt to extract archive
+    const zip = new AdmZip(fileName);
+    try {
+      zip.extractAllTo(path.join(outputDir, 'archive'));
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        console.error(error.message);
+        return 0;
+      }
+    }
+    return zip.getEntries().length;
+  }
+
+  //Clean up the archive folder in the specified directory
+  private cleanupFiles(dir: string): void {
+    try {
+      const folder = path.join(dir, 'archive');
+      emptyDirSync(folder);
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        console.error(error.message);
+      }
+    }
+  }
 }

test/index.test.ts

@@ -3,46 +3,50 @@ import { readdirSync } from 'node:fs';
 import { emptyDirSync } from 'fs-extra';
 import { Readable } from 'node:stream';
 import { ImageGenerator } from '../src/index';
-import { tmpdir } from 'node:os';
 
-const testGerber = path.join(__dirname, 'Arduino-Pro-Mini.zip');
+//Sample data
+const arduinoGerber = path.join(__dirname, 'Arduino-Pro-Mini.zip');
 const incompleteGerber = path.join(__dirname, 'incomplete.zip');
-const testLayers = path.join(__dirname, 'layers');
+
-const emptyFolder = path.join(__dirname, 'layers', 'Empty');
+//Correct folder configuration
-const archiveTestFolder = path.join(__dirname, 'archiveTest');
 const folderConfig = {
   tmpDir: path.join(__dirname, 'tmp'),
   imgDir: path.join(__dirname, 'tmp'),
 };
-const noTempConfig = {
+//Folder configuration with non-existent tmpDir
-  tmpDir: emptyFolder,
-  imgDir: path.join(__dirname, 'tmp'),
-};
 const tmpNotExist = {
   tmpDir: path.join(__dirname, 'InvalidFolderName'),
   imgDir: path.join(__dirname, 'tmp'),
 };
+//Folder configuration with non-existent imgDir
 const imgNotExist = {
   tmpDir: path.join(__dirname, 'tmp'),
   imgDir: path.join(__dirname, 'InvalidFolderName'),
 };
+//Folder configuration with bad permissions on tmpDir
 const tmpBadPerms = {
   tmpDir: path.join(__dirname, 'badPerms'),
   imgDir: path.join(__dirname, 'tmp'),
 };
+//Folder configuration with bad permissions on imgDir
 const imgBadPerms = {
   tmpDir: path.join(__dirname, 'tmp'),
   imgDir: path.join(__dirname, 'badPerms'),
 };
-const noImageConfig = {
+//Correct folder configuration
+const arduinoConfig = {
   tmpDir: path.join(__dirname, 'tmp'),
-  imgDir: emptyFolder,
+  imgDir: path.join(__dirname, 'arduino'),
 };
+
+//Valid image configuration object
 const imgConfig = {
   resizeWidth: 600,
   density: 1000,
   compLevel: 1,
 };
+
+//Valid array of layer names
 const layerNames = [
   'CAMOutputs/DrillFiles/drills.xln',
   'CAMOutputs/GerberFiles/copper_top.gbr',
@@ -52,23 +56,16 @@ const layerNames = [
   'CAMOutputs/GerberFiles/profile.gbr',
 ];
 
-const fileProc = new ImageGenerator(folderConfig, imgConfig, layerNames);
+//===== Tests =====
-
-/**************
- * Tests
- ***************/
 
+//Setup
 beforeAll(() => {
   return emptyDirSync(folderConfig.tmpDir);
 });
 
-beforeEach(() => {
-  return emptyDirSync(emptyFolder);
-});
-
 // Test constructor
 describe('Creating an ImageGenerator object', () => {
-  const imgGen = new ImageGenerator(folderConfig, imgConfig);
+  const imgGen = new ImageGenerator(folderConfig, imgConfig, layerNames);
   test('should create a valid object when passed the correct files and configuration', () => {
     expect(imgGen).toBeInstanceOf(ImageGenerator);
   });
@@ -86,117 +83,72 @@ describe('Creating an ImageGenerator object', () => {
     expect(imgGen.folderConfig.tmpDir).toBe(path.join(__dirname, 'tmp'));
     expect(imgGen.folderConfig.imgDir).toBe(path.join(__dirname, 'tmp'));
   });
+  test('Layers should match layerNames sample array', () => {
+    expect(imgGen.layerNames).toBe(layerNames);
+  });
   afterAll(() => {
     return emptyDirSync(folderConfig.tmpDir);
   });
 });
 
-// Testing folder config
+//Test invalid folder configs
-describe('Passing in', () => {
+describe('Attempting to create ImageGenerator object with', () => {
-  test('a non-existent tmp folder should throw error', () => {
-    expect(() => {
-      new ImageGenerator(tmpNotExist, imgConfig);
-    }).toThrow();
-  });
-  test('a tmp folder with invalid permissions should throw error', () => {
-    expect(() => {
-      new ImageGenerator(tmpBadPerms, imgConfig);
-    }).toThrow();
-  });
-  test('a non-existent img folder should throw error', () => {
-    expect(() => {
-      new ImageGenerator(imgNotExist, imgConfig);
-    }).toThrow();
-  });
-  test('an img folder with invalid permissions should throw error', () => {
-    expect(() => {
-      new ImageGenerator(imgBadPerms, imgConfig);
-    }).toThrow();
-  });
-});
-
-//Layer methods
-describe('Getting layers', () => {
-  const imgGen = new ImageGenerator(folderConfig, imgConfig);
-  test('should return a promise of array of layers', () => {
-    expect(imgGen.getLayers(testLayers, layerNames)).resolves.toBeInstanceOf(
-      Array,
-    );
-  });
-
-  test('should throw error if the layers folder is not valid', () => {
-    expect(() => {
-      imgGen.getLayers('some_invalid_folder', layerNames);
-    }).toThrow();
-  });
-
-  test('should throw error if incorrect number of layers supplied', () => {
-    expect(() => {
-      imgGen.getLayers(emptyFolder, layerNames);
-    }).toThrow();
-  });
-});
-
-//Archive methods
-describe('When extracting an archive', () => {
-  const imgGen = new ImageGenerator(folderConfig, imgConfig);
-  test('a non-existent archive should throw an error', () => {
-    expect(() =>
-      imgGen.extractArchive('invalid.zip', folderConfig.tmpDir),
-    ).toThrow();
-  });
-  test('if the temp dir does not exist it should throw an error', () => {
-    expect(() => imgGen.extractArchive(testGerber, 'some_invalid_dir')).toThrow(
-      Error,
-    );
-  });
-  test('it should load the archive and return the number of files extracted', () => {
-    expect(() => {
-      imgGen.testArchive(testGerber, archiveTestFolder);
-    }).not.toThrow();
-    expect(imgGen.testArchive(testGerber, archiveTestFolder)).toEqual(12);
-  });
-  test('it should extract archive and all files should be present', () => {
-    expect(imgGen.testArchive(testGerber, archiveTestFolder)).toEqual(12);
-    imgGen.extractArchive(testGerber, archiveTestFolder);
-    const dirents = readdirSync(archiveTestFolder, {
-      recursive: true,
-      withFileTypes: true,
-    });
-    const numOutputFiles = dirents.filter((dirent) => dirent.isFile());
-    expect(numOutputFiles).toHaveLength(12);
-  });
-  //clear archive
   afterAll(() => {
-    return emptyDirSync(archiveTestFolder);
+    return emptyDirSync(path.join(__dirname, 'tmp'));
+  });
+  test('non-existent temp folder should throw error', () => {
+    expect(() => {
+      const badGen = new ImageGenerator(tmpNotExist, imgConfig, layerNames);
+    }).toThrow();
+  });
+  test('non-existent image folder should throw error', () => {
+    expect(() => {
+      const badGen = new ImageGenerator(imgNotExist, imgConfig, layerNames);
+    }).toThrow();
+  });
+  test('temp folder with bad permissions should throw error', () => {
+    expect(() => {
+      const badGen = new ImageGenerator(tmpBadPerms, imgConfig, layerNames);
+    }).toThrow();
+  });
+  test('image folder with bad permissions should throw error', () => {
+    expect(() => {
+      const badGen = new ImageGenerator(imgBadPerms, imgConfig, layerNames);
+    }).toThrow();
   });
 });
 
-//Gerber methods
+//Create image from Arduino Gerber
-describe('Converting a gerber to an image', () => {
+describe('Create image from Arduino gerber', () => {
+  beforeAll(() => {
+    return emptyDirSync(path.join(__dirname, 'arduino'));
+  });
   beforeEach(() => {
-    return emptyDirSync(emptyFolder);
+    return emptyDirSync(folderConfig.tmpDir);
   });
-  afterAll(() => {
+  const arduinoGen = new ImageGenerator(arduinoConfig, imgConfig, layerNames);
-    return emptyDirSync(emptyFolder);
+  test('should create a valid object when passed the correct files and configuration', () => {
+    expect(arduinoGen).toBeInstanceOf(ImageGenerator);
   });
-
   test('invalid archive file should throw an error', () => {
-    expect(() => fileProc.gerberToImage('invalid.zip')).toThrow();
+    expect(() => arduinoGen.gerberToImage('invalid.zip')).toThrow();
   });
-  // test('an archive with incomplete set of layers should throw an error', () => {
+  test('arduino archive should resolve promise and return a filename of an image', () => {
-  //   expect(() => fileProc.gerberToImage(incompleteGerber)).toThrow();
-  // });
-  test('gerber archive should resolve promise and return a filename of an image', () => {
     expect.assertions(1);
-    return expect(fileProc.gerberToImage(testGerber)).resolves.toEqual(
+    return expect(arduinoGen.gerberToImage(arduinoGerber)).resolves.toEqual(
       expect.stringContaining('Arduino-Pro-Mini.png'),
     );
   });
-  test('Gerber archive should resolve promise and return a png stream', () => {
+  test('arduino archive should resolve promise and return a png stream', () => {
     expect.assertions(1);
-    return expect(fileProc.gerberToStream(testGerber)).resolves.toBeInstanceOf(
+    return expect(
-      Readable,
+      arduinoGen.gerberToStream(arduinoGerber),
+    ).resolves.toBeInstanceOf(Readable);
+  });
+  test('incomplete archive file should throw an error', () => {
+    expect.assertions(1);
+    return expect(arduinoGen.gerberToImage(incompleteGerber)).rejects.toContain(
+      'Missing',
     );
   });
 });

test/layers/CAMOutputs/DrillFiles/drills.xln

@@ -1,77 +0,0 @@
-M48
-;GenerationSoftware,Autodesk,EAGLE,9.6.2*%
-;CreationDate,2021-02-01T16:14:31Z*%
-FMAT,2
-ICI,OFF
-METRIC,TZ,000.000
-T2C0.508
-T1C1.016
-%
-G90
-M71
-T1
-X16510Y24130
-X13589Y7493
-X2540Y31750
-X5080Y31750
-X7620Y31750
-X10160Y31750
-X12700Y31750
-X15240Y31750
-X13589Y20447
-X13589Y17907
-X1270Y29210
-X1270Y26670
-X1270Y24130
-X1270Y21590
-X1270Y19050
-X1270Y16510
-X1270Y13970
-X1270Y11430
-X1270Y8890
-X1270Y6350
-X1270Y3810
-X1270Y1270
-X16510Y1270
-X16510Y3810
-X16510Y6350
-X16510Y8890
-X16510Y11430
-X16510Y13970
-X16510Y16510
-X16510Y29210
-X16510Y26670
-X13589Y10033
-X16510Y21590
-X16510Y19050
-T2
-X12192Y13970
-X2794Y2159
-X8890Y15621
-X9525Y16891
-X9322Y19812
-X15367Y15240
-X14046Y27280
-X11176Y26162
-X6350Y26416
-X6629Y22200
-X7366Y11557
-X8001Y12700
-X11303Y14986
-X8890Y4572
-X5969Y3048
-X10414Y11557
-X11811Y5842
-X8153Y29261
-X6401Y24130
-X11405Y24130
-X3683Y26035
-X7722Y16942
-X14757Y25400
-X6350Y14478
-X10414Y20447
-X5105Y29286
-X8890Y2667
-X9652Y14478
-X11430Y12700
-M30

test/layers/CAMOutputs/GerberFiles/Other.gbr

@@ -1,44 +0,0 @@
-G04 EAGLE Gerber RS-274X export*
-G75*
-%MOMM*%
-%FSLAX34Y34*%
-%LPD*%
-%INVias*%
-%IPPOS*%
-%AMOC8*
-5,1,8,0,0,1.08239X$1,22.5*%
-G01*
-%ADD10C,1.016000*%
-
-
-D10*
-X114300Y127000D03*
-X96520Y144780D03*
-X88900Y26670D03*
-X51054Y292862D03*
-X104140Y204470D03*
-X63500Y144780D03*
-X147574Y254000D03*
-X77216Y169418D03*
-X36830Y260350D03*
-X114046Y241300D03*
-X64008Y241300D03*
-X81534Y292608D03*
-X118110Y58420D03*
-X104140Y115570D03*
-X59690Y30480D03*
-X88900Y45720D03*
-X113030Y149860D03*
-X80010Y127000D03*
-X73660Y115570D03*
-X66294Y221996D03*
-X63500Y264160D03*
-X111760Y261620D03*
-X140462Y272796D03*
-X153670Y152400D03*
-X93218Y198120D03*
-X95250Y168910D03*
-X88900Y156210D03*
-X27940Y21590D03*
-X121920Y139700D03*
-M02*

test/layers/CAMOutputs/GerberFiles/gerber_job.gbrjob

@@ -1,24 +0,0 @@
-{
-    "Header": {
-        "Comment": "All values are metric (mm)",
-        "CreationDate": "2021-02-01T16:14:31Z",
-        "GenerationSoftware": {
-            "Application": "EAGLE",
-            "Vendor": "Autodesk",
-            "Version": "9.6.2"
-        },
-        "Part": "Single"
-    },
-    "Overall": {
-        "BoardThickness": 1.57,
-        "LayerNumber": 2,
-        "Name": {
-            "ProjectId": "Arduino-Pro-Mini"
-        },
-        "Owner": "nick nick <nick@chaosemerald.co.uk>",
-        "Size": {
-            "X": 17.78,
-            "Y": 33.02
-        }
-    }
-}

test/layers/CAMOutputs/GerberFiles/profile.gbr

@@ -1,20 +0,0 @@
-G04 EAGLE Gerber RS-274X export*
-G75*
-%MOMM*%
-%FSLAX34Y34*%
-%LPD*%
-%IN*%
-%IPPOS*%
-%AMOC8*
-5,1,8,0,0,1.08239X$1,22.5*%
-G01*
-%ADD10C,0.254000*%
-
-
-D10*
-X0Y0D02*
-X177800Y0D01*
-X177800Y330200D01*
-X0Y330200D01*
-X0Y0D01*
-M02*

test/layers/CAMOutputs/GerberFiles/soldermask_bottom.gbr

@@ -1,56 +0,0 @@
-G04 EAGLE Gerber RS-274X export*
-G75*
-%MOMM*%
-%FSLAX34Y34*%
-%LPD*%
-%INSoldermask Bottom*%
-%IPPOS*%
-%AMOC8*
-5,1,8,0,0,1.08239X$1,22.5*%
-G01*
-%ADD10C,2.082800*%
-%ADD11R,1.203200X1.303200*%
-
-
-D10*
-X165100Y292100D03*
-X165100Y266700D03*
-X165100Y241300D03*
-X165100Y215900D03*
-X165100Y190500D03*
-X165100Y165100D03*
-X165100Y139700D03*
-X165100Y114300D03*
-X165100Y88900D03*
-X165100Y63500D03*
-X165100Y38100D03*
-X165100Y12700D03*
-X12700Y12700D03*
-X12700Y38100D03*
-X12700Y63500D03*
-X12700Y88900D03*
-X12700Y114300D03*
-X12700Y139700D03*
-X12700Y165100D03*
-X12700Y190500D03*
-X12700Y215900D03*
-X12700Y241300D03*
-X12700Y266700D03*
-X12700Y292100D03*
-X135890Y179070D03*
-X135890Y204470D03*
-X152400Y317500D03*
-X127000Y317500D03*
-X101600Y317500D03*
-X76200Y317500D03*
-X50800Y317500D03*
-X25400Y317500D03*
-D11*
-X129794Y223148D03*
-X129794Y240148D03*
-X142494Y223148D03*
-X142494Y240148D03*
-D10*
-X135890Y74930D03*
-X135890Y100330D03*
-M02*

test/layers/CAMOutputs/GerberFiles/soldermask_top.gbr

@@ -1,376 +0,0 @@
-G04 EAGLE Gerber RS-274X export*
-G75*
-%MOMM*%
-%FSLAX34Y34*%
-%LPD*%
-%INSoldermask Top*%
-%IPPOS*%
-%AMOC8*
-5,1,8,0,0,1.08239X$1,22.5*%
-G01*
-%ADD10R,1.303200X1.203200*%
-%ADD11R,1.803200X1.603200*%
-%ADD12C,0.505344*%
-%ADD13R,1.203200X1.303200*%
-%ADD14R,1.403200X0.753200*%
-%ADD15C,2.082800*%
-%ADD16R,1.473200X0.762000*%
-%ADD17R,0.762000X1.473200*%
-%ADD18C,0.838200*%
-%ADD19R,1.473200X0.838200*%
-%ADD20R,1.727200X0.965200*%
-%ADD21C,0.653200*%
-%ADD22R,1.534159X3.495041*%
-
-
-D10*
-X80382Y204216D03*
-X63382Y204216D03*
-D11*
-X46990Y274350D03*
-X46990Y246350D03*
-D10*
-X97400Y266700D03*
-X80400Y266700D03*
-D12*
-X94434Y222184D02*
-X94434Y215204D01*
-X94434Y222184D02*
-X101414Y222184D01*
-X101414Y215204D01*
-X94434Y215204D01*
-X94434Y220004D02*
-X101414Y220004D01*
-X76894Y222184D02*
-X76894Y215204D01*
-X76894Y222184D02*
-X83874Y222184D01*
-X83874Y215204D01*
-X76894Y215204D01*
-X76894Y220004D02*
-X83874Y220004D01*
-D13*
-X45466Y43824D03*
-X45466Y60824D03*
-D10*
-X98670Y72390D03*
-X81670Y72390D03*
-D13*
-X45466Y12074D03*
-X45466Y29074D03*
-X137160Y57522D03*
-X137160Y40522D03*
-D12*
-X133670Y11992D02*
-X140650Y11992D01*
-X140650Y5012D01*
-X133670Y5012D01*
-X133670Y11992D01*
-X133670Y9812D02*
-X140650Y9812D01*
-X140650Y29532D02*
-X133670Y29532D01*
-X140650Y29532D02*
-X140650Y22552D01*
-X133670Y22552D01*
-X133670Y29532D01*
-X133670Y27352D02*
-X140650Y27352D01*
-D14*
-X101901Y232308D03*
-X101901Y241808D03*
-X101901Y251308D03*
-X75899Y251308D03*
-X75899Y232308D03*
-D11*
-X132080Y227300D03*
-X132080Y255300D03*
-D15*
-X165100Y292100D03*
-X165100Y266700D03*
-X165100Y241300D03*
-X165100Y215900D03*
-X165100Y190500D03*
-X165100Y165100D03*
-X165100Y139700D03*
-X165100Y114300D03*
-X165100Y88900D03*
-X165100Y63500D03*
-X165100Y38100D03*
-X165100Y12700D03*
-X12700Y12700D03*
-X12700Y38100D03*
-X12700Y63500D03*
-X12700Y88900D03*
-X12700Y114300D03*
-X12700Y139700D03*
-X12700Y165100D03*
-X12700Y190500D03*
-X12700Y215900D03*
-X12700Y241300D03*
-X12700Y266700D03*
-X12700Y292100D03*
-X135890Y179070D03*
-X135890Y204470D03*
-D16*
-G36*
-X80860Y181950D02*
-X70444Y192366D01*
-X75832Y197754D01*
-X86248Y187338D01*
-X80860Y181950D01*
-G37*
-G36*
-X75203Y176293D02*
-X64787Y186709D01*
-X70175Y192097D01*
-X80591Y181681D01*
-X75203Y176293D01*
-G37*
-G36*
-X69546Y170637D02*
-X59130Y181053D01*
-X64518Y186441D01*
-X74934Y176025D01*
-X69546Y170637D01*
-G37*
-G36*
-X63889Y164980D02*
-X53473Y175396D01*
-X58861Y180784D01*
-X69277Y170368D01*
-X63889Y164980D01*
-G37*
-G36*
-X58232Y159323D02*
-X47816Y169739D01*
-X53204Y175127D01*
-X63620Y164711D01*
-X58232Y159323D01*
-G37*
-G36*
-X52575Y153666D02*
-X42159Y164082D01*
-X47547Y169470D01*
-X57963Y159054D01*
-X52575Y153666D01*
-G37*
-G36*
-X46919Y148009D02*
-X36503Y158425D01*
-X41891Y163813D01*
-X52307Y153397D01*
-X46919Y148009D01*
-G37*
-G36*
-X41262Y142352D02*
-X30846Y152768D01*
-X36234Y158156D01*
-X46650Y147740D01*
-X41262Y142352D01*
-G37*
-D17*
-G36*
-X36234Y121244D02*
-X30846Y126632D01*
-X41262Y137048D01*
-X46650Y131660D01*
-X36234Y121244D01*
-G37*
-G36*
-X41891Y115587D02*
-X36503Y120975D01*
-X46919Y131391D01*
-X52307Y126003D01*
-X41891Y115587D01*
-G37*
-G36*
-X47547Y109930D02*
-X42159Y115318D01*
-X52575Y125734D01*
-X57963Y120346D01*
-X47547Y109930D01*
-G37*
-G36*
-X53204Y104273D02*
-X47816Y109661D01*
-X58232Y120077D01*
-X63620Y114689D01*
-X53204Y104273D01*
-G37*
-G36*
-X58861Y98616D02*
-X53473Y104004D01*
-X63889Y114420D01*
-X69277Y109032D01*
-X58861Y98616D01*
-G37*
-G36*
-X64518Y92959D02*
-X59130Y98347D01*
-X69546Y108763D01*
-X74934Y103375D01*
-X64518Y92959D01*
-G37*
-G36*
-X70175Y87303D02*
-X64787Y92691D01*
-X75203Y103107D01*
-X80591Y97719D01*
-X70175Y87303D01*
-G37*
-G36*
-X75832Y81646D02*
-X70444Y87034D01*
-X80860Y97450D01*
-X86248Y92062D01*
-X75832Y81646D01*
-G37*
-D16*
-G36*
-X101968Y81646D02*
-X91552Y92062D01*
-X96940Y97450D01*
-X107356Y87034D01*
-X101968Y81646D01*
-G37*
-G36*
-X107625Y87303D02*
-X97209Y97719D01*
-X102597Y103107D01*
-X113013Y92691D01*
-X107625Y87303D01*
-G37*
-G36*
-X113282Y92959D02*
-X102866Y103375D01*
-X108254Y108763D01*
-X118670Y98347D01*
-X113282Y92959D01*
-G37*
-G36*
-X118939Y98616D02*
-X108523Y109032D01*
-X113911Y114420D01*
-X124327Y104004D01*
-X118939Y98616D01*
-G37*
-G36*
-X124596Y104273D02*
-X114180Y114689D01*
-X119568Y120077D01*
-X129984Y109661D01*
-X124596Y104273D01*
-G37*
-G36*
-X130253Y109930D02*
-X119837Y120346D01*
-X125225Y125734D01*
-X135641Y115318D01*
-X130253Y109930D01*
-G37*
-G36*
-X135909Y115587D02*
-X125493Y126003D01*
-X130881Y131391D01*
-X141297Y120975D01*
-X135909Y115587D01*
-G37*
-G36*
-X141566Y121244D02*
-X131150Y131660D01*
-X136538Y137048D01*
-X146954Y126632D01*
-X141566Y121244D01*
-G37*
-D17*
-G36*
-X136538Y142352D02*
-X131150Y147740D01*
-X141566Y158156D01*
-X146954Y152768D01*
-X136538Y142352D01*
-G37*
-G36*
-X130881Y148009D02*
-X125493Y153397D01*
-X135909Y163813D01*
-X141297Y158425D01*
-X130881Y148009D01*
-G37*
-G36*
-X125225Y153666D02*
-X119837Y159054D01*
-X130253Y169470D01*
-X135641Y164082D01*
-X125225Y153666D01*
-G37*
-G36*
-X119568Y159323D02*
-X114180Y164711D01*
-X124596Y175127D01*
-X129984Y169739D01*
-X119568Y159323D01*
-G37*
-G36*
-X113911Y164980D02*
-X108523Y170368D01*
-X118939Y180784D01*
-X124327Y175396D01*
-X113911Y164980D01*
-G37*
-G36*
-X108254Y170637D02*
-X102866Y176025D01*
-X113282Y186441D01*
-X118670Y181053D01*
-X108254Y170637D01*
-G37*
-G36*
-X102597Y176293D02*
-X97209Y181681D01*
-X107625Y192097D01*
-X113013Y186709D01*
-X102597Y176293D01*
-G37*
-G36*
-X96940Y181950D02*
-X91552Y187338D01*
-X101968Y197754D01*
-X107356Y192366D01*
-X96940Y181950D01*
-G37*
-D15*
-X152400Y317500D03*
-X127000Y317500D03*
-X101600Y317500D03*
-X76200Y317500D03*
-X50800Y317500D03*
-X25400Y317500D03*
-D10*
-X136516Y292100D03*
-X119516Y292100D03*
-D18*
-X39370Y292100D03*
-X124460Y25400D03*
-D19*
-X46990Y226369D03*
-X46990Y218131D03*
-D20*
-X118110Y7620D03*
-X62230Y7620D03*
-X118110Y45720D03*
-X62230Y45720D03*
-D15*
-X135890Y74930D03*
-X135890Y100330D03*
-D21*
-X49693Y178246D02*
-X35143Y178246D01*
-X35143Y190246D02*
-X49693Y190246D01*
-X49693Y202246D02*
-X35143Y202246D01*
-D22*
-X42443Y190221D03*
-M02*

test/layers/CAMOutputs/GerberFiles/solderpaste_bottom.gbr

@@ -1,19 +0,0 @@
-G04 EAGLE Gerber RS-274X export*
-G75*
-%MOMM*%
-%FSLAX34Y34*%
-%LPD*%
-%INSolderpaste Bottom*%
-%IPPOS*%
-%AMOC8*
-5,1,8,0,0,1.08239X$1,22.5*%
-G01*
-%ADD10R,1.000000X1.100000*%
-
-
-D10*
-X129794Y223148D03*
-X129794Y240148D03*
-X142494Y223148D03*
-X142494Y240148D03*
-M02*

test/layers/CAMOutputs/GerberFiles/solderpaste_top.gbr

@@ -1,341 +0,0 @@
-G04 EAGLE Gerber RS-274X export*
-G75*
-%MOMM*%
-%FSLAX34Y34*%
-%LPD*%
-%INSolderpaste Top*%
-%IPPOS*%
-%AMOC8*
-5,1,8,0,0,1.08239X$1,22.5*%
-G01*
-%ADD10R,1.100000X1.000000*%
-%ADD11R,1.600000X1.400000*%
-%ADD12C,0.300000*%
-%ADD13R,1.000000X1.100000*%
-%ADD14R,1.200000X0.550000*%
-%ADD15R,1.270000X0.558800*%
-%ADD16R,0.558800X1.270000*%
-%ADD17R,1.270000X0.635000*%
-%ADD18R,2.286000X2.438400*%
-%ADD19R,1.524000X0.762000*%
-%ADD20C,0.450000*%
-
-
-D10*
-X80382Y204216D03*
-X63382Y204216D03*
-D11*
-X46990Y274350D03*
-X46990Y246350D03*
-D10*
-X97400Y266700D03*
-X80400Y266700D03*
-D12*
-X94424Y222194D02*
-X94424Y215194D01*
-X94424Y222194D02*
-X101424Y222194D01*
-X101424Y215194D01*
-X94424Y215194D01*
-X94424Y218044D02*
-X101424Y218044D01*
-X101424Y220894D02*
-X94424Y220894D01*
-X76884Y222194D02*
-X76884Y215194D01*
-X76884Y222194D02*
-X83884Y222194D01*
-X83884Y215194D01*
-X76884Y215194D01*
-X76884Y218044D02*
-X83884Y218044D01*
-X83884Y220894D02*
-X76884Y220894D01*
-D13*
-X45466Y43824D03*
-X45466Y60824D03*
-D10*
-X98670Y72390D03*
-X81670Y72390D03*
-D13*
-X45466Y12074D03*
-X45466Y29074D03*
-X137160Y57522D03*
-X137160Y40522D03*
-D12*
-X133660Y12002D02*
-X140660Y12002D01*
-X140660Y5002D01*
-X133660Y5002D01*
-X133660Y12002D01*
-X133660Y7852D02*
-X140660Y7852D01*
-X140660Y10702D02*
-X133660Y10702D01*
-X133660Y29542D02*
-X140660Y29542D01*
-X140660Y22542D01*
-X133660Y22542D01*
-X133660Y29542D01*
-X133660Y25392D02*
-X140660Y25392D01*
-X140660Y28242D02*
-X133660Y28242D01*
-D14*
-X101901Y232308D03*
-X101901Y241808D03*
-X101901Y251308D03*
-X75899Y251308D03*
-X75899Y232308D03*
-D11*
-X132080Y227300D03*
-X132080Y255300D03*
-D15*
-G36*
-X80860Y183387D02*
-X71881Y192366D01*
-X75832Y196317D01*
-X84811Y187338D01*
-X80860Y183387D01*
-G37*
-G36*
-X75203Y177730D02*
-X66224Y186709D01*
-X70175Y190660D01*
-X79154Y181681D01*
-X75203Y177730D01*
-G37*
-G36*
-X69546Y172074D02*
-X60567Y181053D01*
-X64518Y185004D01*
-X73497Y176025D01*
-X69546Y172074D01*
-G37*
-G36*
-X63889Y166417D02*
-X54910Y175396D01*
-X58861Y179347D01*
-X67840Y170368D01*
-X63889Y166417D01*
-G37*
-G36*
-X58232Y160760D02*
-X49253Y169739D01*
-X53204Y173690D01*
-X62183Y164711D01*
-X58232Y160760D01*
-G37*
-G36*
-X52575Y155103D02*
-X43596Y164082D01*
-X47547Y168033D01*
-X56526Y159054D01*
-X52575Y155103D01*
-G37*
-G36*
-X46919Y149446D02*
-X37940Y158425D01*
-X41891Y162376D01*
-X50870Y153397D01*
-X46919Y149446D01*
-G37*
-G36*
-X41262Y143789D02*
-X32283Y152768D01*
-X36234Y156719D01*
-X45213Y147740D01*
-X41262Y143789D01*
-G37*
-D16*
-G36*
-X36234Y122681D02*
-X32283Y126632D01*
-X41262Y135611D01*
-X45213Y131660D01*
-X36234Y122681D01*
-G37*
-G36*
-X41891Y117024D02*
-X37940Y120975D01*
-X46919Y129954D01*
-X50870Y126003D01*
-X41891Y117024D01*
-G37*
-G36*
-X47547Y111367D02*
-X43596Y115318D01*
-X52575Y124297D01*
-X56526Y120346D01*
-X47547Y111367D01*
-G37*
-G36*
-X53204Y105710D02*
-X49253Y109661D01*
-X58232Y118640D01*
-X62183Y114689D01*
-X53204Y105710D01*
-G37*
-G36*
-X58861Y100053D02*
-X54910Y104004D01*
-X63889Y112983D01*
-X67840Y109032D01*
-X58861Y100053D01*
-G37*
-G36*
-X64518Y94396D02*
-X60567Y98347D01*
-X69546Y107326D01*
-X73497Y103375D01*
-X64518Y94396D01*
-G37*
-G36*
-X70175Y88740D02*
-X66224Y92691D01*
-X75203Y101670D01*
-X79154Y97719D01*
-X70175Y88740D01*
-G37*
-G36*
-X75832Y83083D02*
-X71881Y87034D01*
-X80860Y96013D01*
-X84811Y92062D01*
-X75832Y83083D01*
-G37*
-D15*
-G36*
-X101968Y83083D02*
-X92989Y92062D01*
-X96940Y96013D01*
-X105919Y87034D01*
-X101968Y83083D01*
-G37*
-G36*
-X107625Y88740D02*
-X98646Y97719D01*
-X102597Y101670D01*
-X111576Y92691D01*
-X107625Y88740D01*
-G37*
-G36*
-X113282Y94396D02*
-X104303Y103375D01*
-X108254Y107326D01*
-X117233Y98347D01*
-X113282Y94396D01*
-G37*
-G36*
-X118939Y100053D02*
-X109960Y109032D01*
-X113911Y112983D01*
-X122890Y104004D01*
-X118939Y100053D01*
-G37*
-G36*
-X124596Y105710D02*
-X115617Y114689D01*
-X119568Y118640D01*
-X128547Y109661D01*
-X124596Y105710D01*
-G37*
-G36*
-X130253Y111367D02*
-X121274Y120346D01*
-X125225Y124297D01*
-X134204Y115318D01*
-X130253Y111367D01*
-G37*
-G36*
-X135909Y117024D02*
-X126930Y126003D01*
-X130881Y129954D01*
-X139860Y120975D01*
-X135909Y117024D01*
-G37*
-G36*
-X141566Y122681D02*
-X132587Y131660D01*
-X136538Y135611D01*
-X145517Y126632D01*
-X141566Y122681D01*
-G37*
-D16*
-G36*
-X136538Y143789D02*
-X132587Y147740D01*
-X141566Y156719D01*
-X145517Y152768D01*
-X136538Y143789D01*
-G37*
-G36*
-X130881Y149446D02*
-X126930Y153397D01*
-X135909Y162376D01*
-X139860Y158425D01*
-X130881Y149446D01*
-G37*
-G36*
-X125225Y155103D02*
-X121274Y159054D01*
-X130253Y168033D01*
-X134204Y164082D01*
-X125225Y155103D01*
-G37*
-G36*
-X119568Y160760D02*
-X115617Y164711D01*
-X124596Y173690D01*
-X128547Y169739D01*
-X119568Y160760D01*
-G37*
-G36*
-X113911Y166417D02*
-X109960Y170368D01*
-X118939Y179347D01*
-X122890Y175396D01*
-X113911Y166417D01*
-G37*
-G36*
-X108254Y172074D02*
-X104303Y176025D01*
-X113282Y185004D01*
-X117233Y181053D01*
-X108254Y172074D01*
-G37*
-G36*
-X102597Y177730D02*
-X98646Y181681D01*
-X107625Y190660D01*
-X111576Y186709D01*
-X102597Y177730D01*
-G37*
-G36*
-X96940Y183387D02*
-X92989Y187338D01*
-X101968Y196317D01*
-X105919Y192366D01*
-X96940Y183387D01*
-G37*
-D10*
-X136516Y292100D03*
-X119516Y292100D03*
-D17*
-X46990Y226369D03*
-X46990Y218131D03*
-D18*
-X46990Y222250D03*
-D19*
-X118110Y7620D03*
-X62230Y7620D03*
-X118110Y45720D03*
-X62230Y45720D03*
-D20*
-X49693Y178246D02*
-X35143Y178246D01*
-X35143Y190246D02*
-X49693Y190246D01*
-X49693Y202246D02*
-X35143Y202246D01*
-M02*