@zergai/ztc 0.2.5-dev.36050816660 → 0.2.6-dev.36102446685

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/comment/vml-notes-xform.js

@@ -1,6 +1,5 @@
-"use strict";
-
 const XmlStream = require('../../../utils/xml-stream');
+
 const BaseXform = require('../base-xform');
 const VmlShapeXform = require('./vml-shape-xform');
 
@@ -10,42 +9,39 @@ class VmlNotesXform extends BaseXform {
   constructor() {
     super();
     this.map = {
-      'v:shape': new VmlShapeXform()
+      'v:shape': new VmlShapeXform(),
     };
   }
+
   get tag() {
     return 'xml';
   }
+
   render(xmlStream, model) {
     xmlStream.openXml(XmlStream.StdDocAttributes);
     xmlStream.openNode(this.tag, VmlNotesXform.DRAWING_ATTRIBUTES);
-    xmlStream.openNode('o:shapelayout', {
-      'v:ext': 'edit'
-    });
-    xmlStream.leafNode('o:idmap', {
-      'v:ext': 'edit',
-      data: 1
-    });
+
+    xmlStream.openNode('o:shapelayout', {'v:ext': 'edit'});
+    xmlStream.leafNode('o:idmap', {'v:ext': 'edit', data: 1});
     xmlStream.closeNode();
+
     xmlStream.openNode('v:shapetype', {
       id: '_x0000_t202',
       coordsize: '21600,21600',
       'o:spt': 202,
-      path: 'm,l,21600r21600,l21600,xe'
-    });
-    xmlStream.leafNode('v:stroke', {
-      joinstyle: 'miter'
-    });
-    xmlStream.leafNode('v:path', {
-      gradientshapeok: 't',
-      'o:connecttype': 'rect'
+      path: 'm,l,21600r21600,l21600,xe',
     });
+    xmlStream.leafNode('v:stroke', {joinstyle: 'miter'});
+    xmlStream.leafNode('v:path', {gradientshapeok: 't', 'o:connecttype': 'rect'});
     xmlStream.closeNode();
+
     model.comments.forEach((item, index) => {
       this.map['v:shape'].render(xmlStream, item, index);
     });
+
     xmlStream.closeNode();
   }
+
   parseOpen(node) {
     if (this.parser) {
       this.parser.parseOpen(node);
@@ -55,7 +51,7 @@ class VmlNotesXform extends BaseXform {
       case this.tag:
         this.reset();
         this.model = {
-          comments: []
+          comments: [],
         };
         break;
       default:
@@ -67,11 +63,13 @@ class VmlNotesXform extends BaseXform {
     }
     return true;
   }
+
   parseText(text) {
     if (this.parser) {
       this.parser.parseText(text);
     }
   }
+
   parseClose(name) {
     if (this.parser) {
       if (!this.parser.parseClose(name)) {
@@ -88,6 +86,7 @@ class VmlNotesXform extends BaseXform {
         return true;
     }
   }
+
   reconcile(model, options) {
     model.anchors.forEach(anchor => {
       if (anchor.br) {
@@ -98,10 +97,11 @@ class VmlNotesXform extends BaseXform {
     });
   }
 }
+
 VmlNotesXform.DRAWING_ATTRIBUTES = {
   'xmlns:v': 'urn:schemas-microsoft-com:vml',
   'xmlns:o': 'urn:schemas-microsoft-com:office:office',
-  'xmlns:x': 'urn:schemas-microsoft-com:office:excel'
+  'xmlns:x': 'urn:schemas-microsoft-com:office:excel',
 };
+
 module.exports = VmlNotesXform;
-//# sourceMappingURL=vml-notes-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/comment/vml-shape-xform.js

@@ -1,50 +1,48 @@
-"use strict";
-
 const BaseXform = require('../base-xform');
 const VmlTextboxXform = require('./vml-textbox-xform');
 const VmlClientDataXform = require('./vml-client-data-xform');
+
 class VmlShapeXform extends BaseXform {
   constructor() {
     super();
     this.map = {
       'v:textbox': new VmlTextboxXform(),
-      'x:ClientData': new VmlClientDataXform()
+      'x:ClientData': new VmlClientDataXform(),
     };
   }
+
   get tag() {
     return 'v:shape';
   }
+
   render(xmlStream, model, index) {
     xmlStream.openNode('v:shape', VmlShapeXform.V_SHAPE_ATTRIBUTES(model, index));
-    xmlStream.leafNode('v:fill', {
-      color2: 'infoBackground [80]'
-    });
-    xmlStream.leafNode('v:shadow', {
-      color: 'none [81]',
-      obscured: 't'
-    });
-    xmlStream.leafNode('v:path', {
-      'o:connecttype': 'none'
-    });
+
+    xmlStream.leafNode('v:fill', {color2: 'infoBackground [80]'});
+    xmlStream.leafNode('v:shadow', {color: 'none [81]', obscured: 't'});
+    xmlStream.leafNode('v:path', {'o:connecttype': 'none'});
     this.map['v:textbox'].render(xmlStream, model);
     this.map['x:ClientData'].render(xmlStream, model);
+
     xmlStream.closeNode();
   }
+
   parseOpen(node) {
     if (this.parser) {
       this.parser.parseOpen(node);
       return true;
     }
+
     switch (node.name) {
       case this.tag:
         this.reset();
         this.model = {
           margins: {
-            insetmode: node.attributes['o:insetmode']
+            insetmode: node.attributes['o:insetmode'],
           },
           anchor: '',
           editAs: '',
-          protection: {}
+          protection: {},
         };
         break;
       default:
@@ -56,11 +54,13 @@ class VmlShapeXform extends BaseXform {
     }
     return true;
   }
+
   parseText(text) {
     if (this.parser) {
       this.parser.parseText(text);
     }
   }
+
   parseClose(name) {
     if (this.parser) {
       if (!this.parser.parseClose(name)) {
@@ -71,7 +71,8 @@ class VmlShapeXform extends BaseXform {
     switch (name) {
       case this.tag:
         this.model.margins.inset = this.map['v:textbox'].model && this.map['v:textbox'].model.inset;
-        this.model.protection = this.map['x:ClientData'].model && this.map['x:ClientData'].model.protection;
+        this.model.protection =
+          this.map['x:ClientData'].model && this.map['x:ClientData'].model.protection;
         this.model.anchor = this.map['x:ClientData'].model && this.map['x:ClientData'].model.anchor;
         this.model.editAs = this.map['x:ClientData'].model && this.map['x:ClientData'].model.editAs;
         return false;
@@ -80,13 +81,15 @@ class VmlShapeXform extends BaseXform {
     }
   }
 }
+
 VmlShapeXform.V_SHAPE_ATTRIBUTES = (model, index) => ({
   id: `_x0000_s${1025 + index}`,
   type: '#_x0000_t202',
-  style: 'position:absolute; margin-left:105.3pt;margin-top:10.5pt;width:97.8pt;height:59.1pt;z-index:1;visibility:hidden',
+  style:
+    'position:absolute; margin-left:105.3pt;margin-top:10.5pt;width:97.8pt;height:59.1pt;z-index:1;visibility:hidden',
   fillcolor: 'infoBackground [80]',
   strokecolor: 'none [81]',
-  'o:insetmode': model.note.margins && model.note.margins.insetmode
+  'o:insetmode': model.note.margins && model.note.margins.insetmode,
 });
+
 module.exports = VmlShapeXform;
-//# sourceMappingURL=vml-shape-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/comment/vml-textbox-xform.js

@@ -1,53 +1,56 @@
-"use strict";
-
 const BaseXform = require('../base-xform');
+
 class VmlTextboxXform extends BaseXform {
   get tag() {
     return 'v:textbox';
   }
+
   conversionUnit(value, multiple, unit) {
     return `${parseFloat(value) * multiple.toFixed(2)}${unit}`;
   }
+
   reverseConversionUnit(inset) {
     return (inset || '').split(',').map(margin => {
       return Number(parseFloat(this.conversionUnit(parseFloat(margin), 0.1, '')).toFixed(2));
     });
   }
+
   render(xmlStream, model) {
     const attributes = {
-      style: 'mso-direction-alt:auto'
+      style: 'mso-direction-alt:auto',
     };
     if (model && model.note) {
-      let {
-        inset
-      } = model.note && model.note.margins;
+      let {inset} = model.note && model.note.margins;
       if (Array.isArray(inset)) {
-        inset = inset.map(margin => {
-          return this.conversionUnit(margin, 10, 'mm');
-        }).join(',');
+        inset = inset
+          .map(margin => {
+            return this.conversionUnit(margin, 10, 'mm');
+          })
+          .join(',');
       }
       if (inset) {
         attributes.inset = inset;
       }
     }
     xmlStream.openNode('v:textbox', attributes);
-    xmlStream.leafNode('div', {
-      style: 'text-align:left'
-    });
+    xmlStream.leafNode('div', {style: 'text-align:left'});
     xmlStream.closeNode();
   }
+
   parseOpen(node) {
     switch (node.name) {
       case this.tag:
         this.model = {
-          inset: this.reverseConversionUnit(node.attributes.inset)
+          inset: this.reverseConversionUnit(node.attributes.inset),
         };
         return true;
       default:
         return true;
     }
   }
+
   parseText() {}
+
   parseClose(name) {
     switch (name) {
       case this.tag:
@@ -57,5 +60,5 @@ class VmlTextboxXform extends BaseXform {
     }
   }
 }
+
 module.exports = VmlTextboxXform;
-//# sourceMappingURL=vml-textbox-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/composite-xform.js

@@ -1,5 +1,3 @@
-"use strict";
-
 const BaseXform = require('./base-xform');
 
 /* 'virtual' methods used as a form of documentation */
@@ -11,6 +9,7 @@ class CompositeXform extends BaseXform {
   createNewModel(node) {
     return {};
   }
+
   parseOpen(node) {
     // Typical pattern for composite xform
     this.parser = this.parser || this.map[node.name];
@@ -18,23 +17,28 @@ class CompositeXform extends BaseXform {
       this.parser.parseOpen(node);
       return true;
     }
+
     if (node.name === this.tag) {
       this.model = this.createNewModel(node);
       return true;
     }
+
     return false;
   }
+
   parseText(text) {
     // Default implementation. Send text to child parser
     if (this.parser) {
       this.parser.parseText(text);
     }
   }
+
   onParserClose(name, parser) {
     // parseClose has seen a child parser close
     // now need to incorporate into this.model somehow
     this.model[name] = parser.model;
   }
+
   parseClose(name) {
     // Default implementation
     if (this.parser) {
@@ -44,8 +48,9 @@ class CompositeXform extends BaseXform {
       }
       return true;
     }
+
     return name !== this.tag;
   }
 }
+
 module.exports = CompositeXform;
-//# sourceMappingURL=composite-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/core/app-heading-pairs-xform.js

@@ -1,30 +1,32 @@
-"use strict";
-
 const BaseXform = require('../base-xform');
+
 class AppHeadingPairsXform extends BaseXform {
   render(xmlStream, model) {
     xmlStream.openNode('HeadingPairs');
-    xmlStream.openNode('vt:vector', {
-      size: 2,
-      baseType: 'variant'
-    });
+    xmlStream.openNode('vt:vector', {size: 2, baseType: 'variant'});
+
     xmlStream.openNode('vt:variant');
     xmlStream.leafNode('vt:lpstr', undefined, 'Worksheets');
     xmlStream.closeNode();
+
     xmlStream.openNode('vt:variant');
     xmlStream.leafNode('vt:i4', undefined, model.length);
     xmlStream.closeNode();
+
     xmlStream.closeNode();
     xmlStream.closeNode();
   }
+
   parseOpen(node) {
     // no parsing
     return node.name === 'HeadingPairs';
   }
+
   parseText() {}
+
   parseClose(name) {
     return name !== 'HeadingPairs';
   }
 }
+
 module.exports = AppHeadingPairsXform;
-//# sourceMappingURL=app-heading-pairs-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/core/app-titles-of-parts-xform.js

@@ -1,27 +1,28 @@
-"use strict";
-
 const BaseXform = require('../base-xform');
+
 class AppTitlesOfPartsXform extends BaseXform {
   render(xmlStream, model) {
     xmlStream.openNode('TitlesOfParts');
-    xmlStream.openNode('vt:vector', {
-      size: model.length,
-      baseType: 'lpstr'
-    });
+    xmlStream.openNode('vt:vector', {size: model.length, baseType: 'lpstr'});
+
     model.forEach(sheet => {
       xmlStream.leafNode('vt:lpstr', undefined, sheet.name);
     });
+
     xmlStream.closeNode();
     xmlStream.closeNode();
   }
+
   parseOpen(node) {
     // no parsing
     return node.name === 'TitlesOfParts';
   }
+
   parseText() {}
+
   parseClose(name) {
     return name !== 'TitlesOfParts';
   }
 }
+
 module.exports = AppTitlesOfPartsXform;
-//# sourceMappingURL=app-titles-of-parts-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/core/app-xform.js

@@ -1,40 +1,44 @@
-"use strict";
-
 const XmlStream = require('../../../utils/xml-stream');
 const BaseXform = require('../base-xform');
 const StringXform = require('../simple/string-xform');
+
 const AppHeadingPairsXform = require('./app-heading-pairs-xform');
 const AppTitleOfPartsXform = require('./app-titles-of-parts-xform');
+
 class AppXform extends BaseXform {
   constructor() {
     super();
+
     this.map = {
-      Company: new StringXform({
-        tag: 'Company'
-      }),
-      Manager: new StringXform({
-        tag: 'Manager'
-      }),
+      Company: new StringXform({tag: 'Company'}),
+      Manager: new StringXform({tag: 'Manager'}),
       HeadingPairs: new AppHeadingPairsXform(),
-      TitleOfParts: new AppTitleOfPartsXform()
+      TitleOfParts: new AppTitleOfPartsXform(),
     };
   }
+
   render(xmlStream, model) {
     xmlStream.openXml(XmlStream.StdDocAttributes);
+
     xmlStream.openNode('Properties', AppXform.PROPERTY_ATTRIBUTES);
+
     xmlStream.leafNode('Application', undefined, 'Microsoft Excel');
     xmlStream.leafNode('DocSecurity', undefined, '0');
     xmlStream.leafNode('ScaleCrop', undefined, 'false');
+
     this.map.HeadingPairs.render(xmlStream, model.worksheets);
     this.map.TitleOfParts.render(xmlStream, model.worksheets);
     this.map.Company.render(xmlStream, model.company || '');
     this.map.Manager.render(xmlStream, model.manager);
+
     xmlStream.leafNode('LinksUpToDate', undefined, 'false');
     xmlStream.leafNode('SharedDoc', undefined, 'false');
     xmlStream.leafNode('HyperlinksChanged', undefined, 'false');
     xmlStream.leafNode('AppVersion', undefined, '16.0300');
+
     xmlStream.closeNode();
   }
+
   parseOpen(node) {
     if (this.parser) {
       this.parser.parseOpen(node);
@@ -54,11 +58,13 @@ class AppXform extends BaseXform {
         return false;
     }
   }
+
   parseText(text) {
     if (this.parser) {
       this.parser.parseText(text);
     }
   }
+
   parseClose(name) {
     if (this.parser) {
       if (!this.parser.parseClose(name)) {
@@ -71,7 +77,7 @@ class AppXform extends BaseXform {
         this.model = {
           worksheets: this.map.TitleOfParts.model,
           company: this.map.Company.model,
-          manager: this.map.Manager.model
+          manager: this.map.Manager.model,
         };
         return false;
       default:
@@ -79,15 +85,16 @@ class AppXform extends BaseXform {
     }
   }
 }
-AppXform.DateFormat = function (dt) {
+
+AppXform.DateFormat = function(dt) {
   return dt.toISOString().replace(/[.]\d{3,6}/, '');
 };
-AppXform.DateAttrs = {
-  'xsi:type': 'dcterms:W3CDTF'
-};
+
+AppXform.DateAttrs = {'xsi:type': 'dcterms:W3CDTF'};
+
 AppXform.PROPERTY_ATTRIBUTES = {
   xmlns: 'http://schemas.openxmlformats.org/officeDocument/2006/extended-properties',
-  'xmlns:vt': 'http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes'
+  'xmlns:vt': 'http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes',
 };
+
 module.exports = AppXform;
-//# sourceMappingURL=app-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/core/content-types-xform.js

@@ -1,6 +1,5 @@
-"use strict";
-
 const XmlStream = require('../../../utils/xml-stream');
+
 const BaseXform = require('../base-xform');
 
 // used for rendering the [Content_Types].xml file
@@ -8,105 +7,114 @@ const BaseXform = require('../base-xform');
 class ContentTypesXform extends BaseXform {
   render(xmlStream, model) {
     xmlStream.openXml(XmlStream.StdDocAttributes);
+
     xmlStream.openNode('Types', ContentTypesXform.PROPERTY_ATTRIBUTES);
+
     const mediaHash = {};
     (model.media || []).forEach(medium => {
       if (medium.type === 'image') {
         const imageType = medium.extension;
         if (!mediaHash[imageType]) {
           mediaHash[imageType] = true;
-          xmlStream.leafNode('Default', {
-            Extension: imageType,
-            ContentType: `image/${imageType}`
-          });
+          xmlStream.leafNode('Default', {Extension: imageType, ContentType: `image/${imageType}`});
         }
       }
     });
+
     xmlStream.leafNode('Default', {
       Extension: 'rels',
-      ContentType: 'application/vnd.openxmlformats-package.relationships+xml'
-    });
-    xmlStream.leafNode('Default', {
-      Extension: 'xml',
-      ContentType: 'application/xml'
+      ContentType: 'application/vnd.openxmlformats-package.relationships+xml',
     });
+    xmlStream.leafNode('Default', {Extension: 'xml', ContentType: 'application/xml'});
+
     xmlStream.leafNode('Override', {
       PartName: '/xl/workbook.xml',
-      ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml'
+      ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml',
     });
+
     model.worksheets.forEach(worksheet => {
       const name = `/xl/worksheets/sheet${worksheet.id}.xml`;
       xmlStream.leafNode('Override', {
         PartName: name,
-        ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml'
+        ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml',
       });
     });
+
     xmlStream.leafNode('Override', {
       PartName: '/xl/theme/theme1.xml',
-      ContentType: 'application/vnd.openxmlformats-officedocument.theme+xml'
+      ContentType: 'application/vnd.openxmlformats-officedocument.theme+xml',
     });
     xmlStream.leafNode('Override', {
       PartName: '/xl/styles.xml',
-      ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml'
+      ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml',
     });
+
     const hasSharedStrings = model.sharedStrings && model.sharedStrings.count;
     if (hasSharedStrings) {
       xmlStream.leafNode('Override', {
         PartName: '/xl/sharedStrings.xml',
-        ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml'
+        ContentType:
+          'application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml',
       });
     }
+
     if (model.tables) {
       model.tables.forEach(table => {
         xmlStream.leafNode('Override', {
           PartName: `/xl/tables/${table.target}`,
-          ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml'
+          ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml',
         });
       });
     }
+
     if (model.drawings) {
       model.drawings.forEach(drawing => {
         xmlStream.leafNode('Override', {
           PartName: `/xl/drawings/${drawing.name}.xml`,
-          ContentType: 'application/vnd.openxmlformats-officedocument.drawing+xml'
+          ContentType: 'application/vnd.openxmlformats-officedocument.drawing+xml',
         });
       });
     }
+
     if (model.commentRefs) {
       xmlStream.leafNode('Default', {
         Extension: 'vml',
-        ContentType: 'application/vnd.openxmlformats-officedocument.vmlDrawing'
+        ContentType: 'application/vnd.openxmlformats-officedocument.vmlDrawing',
       });
-      model.commentRefs.forEach(_ref => {
-        let {
-          commentName
-        } = _ref;
+
+      model.commentRefs.forEach(({commentName}) => {
         xmlStream.leafNode('Override', {
           PartName: `/xl/${commentName}.xml`,
-          ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml'
+          ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml',
         });
       });
     }
+
     xmlStream.leafNode('Override', {
       PartName: '/docProps/core.xml',
-      ContentType: 'application/vnd.openxmlformats-package.core-properties+xml'
+      ContentType: 'application/vnd.openxmlformats-package.core-properties+xml',
     });
     xmlStream.leafNode('Override', {
       PartName: '/docProps/app.xml',
-      ContentType: 'application/vnd.openxmlformats-officedocument.extended-properties+xml'
+      ContentType: 'application/vnd.openxmlformats-officedocument.extended-properties+xml',
     });
+
     xmlStream.closeNode();
   }
+
   parseOpen() {
     return false;
   }
+
   parseText() {}
+
   parseClose() {
     return false;
   }
 }
+
 ContentTypesXform.PROPERTY_ATTRIBUTES = {
-  xmlns: 'http://schemas.openxmlformats.org/package/2006/content-types'
+  xmlns: 'http://schemas.openxmlformats.org/package/2006/content-types',
 };
+
 module.exports = ContentTypesXform;
-//# sourceMappingURL=content-types-xform.js.map