svgtiler/lib/svgtiler.js

#!/usr/bin/env node
(function() {
;
var ASCIIDrawing, ASCIIMapping, CSVDrawing, CoffeeMapping, Context, DOMParser, DSVDrawing, Drawing, Drawings, DynamicSymbol, Input, JSMapping, Mapping, Mappings, SSVDrawing, SVGNS, SVGTilerException, StaticSymbol, Symbol, TSVDrawing, XLINKNS, XLSXDrawings, XMLSerializer, allBlank, attributeOrStyle, blankCells, bufferSize, convertSVG, domImplementation, escapeId, exports, extensionMap, extensionOf, fs, graphemeSplitter, help, isAuto, main, overflowBox, parseNum, path, postprocess, prettyXML, sanitize, splitIntoLines, svgBBox, svgtiler, unrecognizedSymbol, whitespace, xmldom, zIndex, zeroSizeReplacement,
  indexOf = [].indexOf,
  hasProp = {}.hasOwnProperty;

if (typeof window === "undefined" || window === null) {
  path = require('path');
  fs = require('fs');
  xmldom = require('xmldom');
  DOMParser = xmldom.DOMParser;
  domImplementation = new xmldom.DOMImplementation();
  XMLSerializer = xmldom.XMLSerializer;
  prettyXML = require('prettify-xml');
  graphemeSplitter = new require('grapheme-splitter')();
  svgtiler = require('../package.json');
  require('coffeescript/register');
} else {
  DOMParser = window.DOMParser; // escape CoffeeScript scope
  domImplementation = document.implementation;
  path = {
    extname: function(x) {
      return /\.[^\/]+$/.exec(x)[0];
    },
    dirname: function(x) {
      return /[^]*\/|/.exec(x)[0];
    }
  };
}

SVGNS = 'http://www.w3.org/2000/svg';

XLINKNS = 'http://www.w3.org/1999/xlink';

splitIntoLines = function(data) {
  return data.replace('\r\n', '\n').replace('\r', '\n').split('\n');
};

whitespace = /[\s\uFEFF\xA0]+/; //# based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim

extensionOf = function(filename) {
  return path.extname(filename).toLowerCase();
};

SVGTilerException = class SVGTilerException {
  constructor(message) {
    this.message = message;
  }

  toString() {
    return `svgtiler: ${this.message}`;
  }

};

overflowBox = function(xml) {
  if (xml.documentElement.hasAttribute('overflowBox')) {
    return xml.documentElement.getAttribute('overflowBox').split(/\s*,?\s+/).map(parseFloat);
  } else {
    return null;
  }
};

parseNum = function(x) {
  var parsed;
  parsed = parseFloat(x);
  if (isNaN(parsed)) {
    return null;
  } else {
    return parsed;
  }
};

svgBBox = function(xml) {
  var recurse, viewBox;
  //# xxx Many unsupported features!
  //#   - transformations
  //#   - used symbols/defs
  //#   - paths
  //#   - text
  //#   - line widths which extend bounding box
  if (xml.documentElement.hasAttribute('viewBox')) {
    viewBox = xml.documentElement.getAttribute('viewBox').split(/\s*,?\s+/).map(parseNum);
    if (indexOf.call(viewBox, null) >= 0) {
      return null;
    } else {
      return viewBox;
    }
  } else {
    recurse = function(node) {
      var child, coord, cx, cy, point, points, r, ref, ref1, ref10, ref11, ref12, ref13, ref14, ref15, ref2, ref3, ref4, ref5, ref6, ref7, ref8, ref9, rx, ry, viewBoxes, x1, x2, xmax, xmin, xs, y1, y2, ymax, ymin, ys;
      if (node.nodeType !== node.ELEMENT_NODE || ((ref = node.tagName) === 'defs' || ref === 'symbol' || ref === 'use')) {
        return null;
      }
      switch (node.tagName) {
        case 'rect':
        case 'image':
          //# For <image>, should autodetect image size (#42)
          return [(ref1 = parseNum(node.getAttribute('x'))) != null ? ref1 : 0, (ref2 = parseNum(node.getAttribute('y'))) != null ? ref2 : 0, (ref3 = parseNum(node.getAttribute('width'))) != null ? ref3 : 0, (ref4 = parseNum(node.getAttribute('height'))) != null ? ref4 : 0];
        case 'circle':
          cx = (ref5 = parseNum(node.getAttribute('cx'))) != null ? ref5 : 0;
          cy = (ref6 = parseNum(node.getAttribute('cy'))) != null ? ref6 : 0;
          r = (ref7 = parseNum(node.getAttribute('r'))) != null ? ref7 : 0;
          return [cx - r, cy - r, 2 * r, 2 * r];
        case 'ellipse':
          cx = (ref8 = parseNum(node.getAttribute('cx'))) != null ? ref8 : 0;
          cy = (ref9 = parseNum(node.getAttribute('cy'))) != null ? ref9 : 0;
          rx = (ref10 = parseNum(node.getAttribute('rx'))) != null ? ref10 : 0;
          ry = (ref11 = parseNum(node.getAttribute('ry'))) != null ? ref11 : 0;
          return [cx - rx, cy - ry, 2 * rx, 2 * ry];
        case 'line':
          x1 = (ref12 = parseNum(node.getAttribute('x1'))) != null ? ref12 : 0;
          y1 = (ref13 = parseNum(node.getAttribute('y1'))) != null ? ref13 : 0;
          x2 = (ref14 = parseNum(node.getAttribute('x2'))) != null ? ref14 : 0;
          y2 = (ref15 = parseNum(node.getAttribute('y2'))) != null ? ref15 : 0;
          xmin = Math.min(x1, x2);
          ymin = Math.min(y1, y2);
          return [xmin, ymin, Math.max(x1, x2) - xmin, Math.max(y1, y2) - ymin];
        case 'polyline':
        case 'polygon':
          points = (function() {
            var k, len, ref16, results;
            ref16 = node.getAttribute('points').trim().split(/\s+/);
            results = [];
            for (k = 0, len = ref16.length; k < len; k++) {
              point = ref16[k];
              results.push((function() {
                var l, len1, ref17, results1;
                ref17 = point.split(/,/);
                results1 = [];
                for (l = 0, len1 = ref17.length; l < len1; l++) {
                  coord = ref17[l];
                  results1.push(parseFloat(coord));
                }
                return results1;
              })());
            }
            return results;
          })();
          xs = (function() {
            var k, len, results;
            results = [];
            for (k = 0, len = points.length; k < len; k++) {
              point = points[k];
              results.push(point[0]);
            }
            return results;
          })();
          ys = (function() {
            var k, len, results;
            results = [];
            for (k = 0, len = points.length; k < len; k++) {
              point = points[k];
              results.push(point[1]);
            }
            return results;
          })();
          xmin = Math.min(...xs);
          ymin = Math.min(...ys);
          if (isNaN(xmin) || isNaN(ymin)) { // invalid points attribute; don't render
            return null;
          } else {
            return [xmin, ymin, Math.max(...xs) - xmin, Math.max(...ys) - ymin];
          }
          break;
        default:
          viewBoxes = (function() {
            var k, len, ref16, results;
            ref16 = node.childNodes;
            results = [];
            for (k = 0, len = ref16.length; k < len; k++) {
              child = ref16[k];
              results.push(recurse(child));
            }
            return results;
          })();
          viewBoxes = (function() {
            var k, len, results;
            results = [];
            for (k = 0, len = viewBoxes.length; k < len; k++) {
              viewBox = viewBoxes[k];
              if (viewBox != null) {
                results.push(viewBox);
              }
            }
            return results;
          })();
          xmin = Math.min(...((function() {
            var k, len, results;
            results = [];
            for (k = 0, len = viewBoxes.length; k < len; k++) {
              viewBox = viewBoxes[k];
              results.push(viewBox[0]);
            }
            return results;
          })()));
          ymin = Math.min(...((function() {
            var k, len, results;
            results = [];
            for (k = 0, len = viewBoxes.length; k < len; k++) {
              viewBox = viewBoxes[k];
              results.push(viewBox[1]);
            }
            return results;
          })()));
          xmax = Math.max(...((function() {
            var k, len, results;
            results = [];
            for (k = 0, len = viewBoxes.length; k < len; k++) {
              viewBox = viewBoxes[k];
              results.push(viewBox[0] + viewBox[2]);
            }
            return results;
          })()));
          ymax = Math.max(...((function() {
            var k, len, results;
            results = [];
            for (k = 0, len = viewBoxes.length; k < len; k++) {
              viewBox = viewBoxes[k];
              results.push(viewBox[1] + viewBox[3]);
            }
            return results;
          })()));
          return [xmin, ymin, xmax - xmin, ymax - ymin];
      }
    };
    viewBox = recurse(xml.documentElement);
    if (indexOf.call(viewBox, 2e308) >= 0 || indexOf.call(viewBox, -2e308) >= 0) {
      return null;
    } else {
      return viewBox;
    }
  }
};

isAuto = function(xml, prop) {
  return xml.documentElement.hasAttribute(prop) && /^\s*auto\s*$/i.test(xml.documentElement.getAttribute(prop));
};

attributeOrStyle = function(node, attr, styleKey = attr) {
  var match, style, value;
  if (value = node.getAttribute(attr)) {
    return value.trim();
  } else {
    style = node.getAttribute('style');
    if (style) {
      match = /(?:^|;)\s*#{styleKey}\s*:\s*([^;\s][^;]*)/i.exec(style);
      return match != null ? match[1] : void 0;
    }
  }
};

zIndex = function(node) {
  var z;
  //# Check whether DOM node has a specified z-index, defaulting to zero.
  //# Note that z-index must be an integer.
  //# 1. https://www.w3.org/Graphics/SVG/WG/wiki/Proposals/z-index suggests
  //# a z-index="..." attribute.  Check for this first.
  //# 2. Look for style="z-index:..." as in HTML.
  z = parseInt(attributeOrStyle(node, 'z-index'));
  if (isNaN(z)) {
    return 0;
  } else {
    return z;
  }
};

Symbol = (function() {
  class Symbol {
    static parse(key, data, dirname) {
      var extension, filename, size;
      if (data == null) {
        throw new SVGTilerException(`Attempt to create symbol '${key}' without data`);
      } else if (typeof data === 'function') {
        return new DynamicSymbol(key, data, dirname);
      } else if (data.function != null) {
        return new DynamicSymbol(key, data.function, dirname);
      } else {
        //# Render Preact virtual dom nodes (e.g. from JSX notation) into strings.
        //# Serialization + parsing shouldn't be necessary, but this lets us
        //# deal with one parsed format (xmldom).
        if (typeof data === 'object' && (data.type != null) && (data.props != null)) {
          data = require('preact-render-to-string')(data);
        }
        return new StaticSymbol(key, (function() {
          if (typeof data === 'string') {
            if (data.trim() === '') { //# Blank SVG treated as 0x0 symbol
              return {
                svg: '<symbol viewBox="0 0 0 0"/>'
              };
            } else if (data.indexOf('<') < 0) { //# No <'s -> interpret as filename
              if (dirname != null) {
                filename = path.join(dirname, data);
              } else {
                filename = data;
              }
              extension = extensionOf(data);
              //# <image> tag documentation: "Conforming SVG viewers need to
              //# support at least PNG, JPEG and SVG format files."
              //# [https://svgwg.org/svg2-draft/embedded.html#ImageElement]
              switch (extension) {
                case '.png':
                case '.jpg':
                case '.jpeg':
                case '.gif':
                  size = require('image-size')(filename);
                  return {
                    svg: `<image xlink:href="${encodeURI(data)}" width="${size.width}" height="${size.height}"${this.imageRendering}/>`
                  };
                case '.svg':
                  return {
                    filename: filename,
                    svg: fs.readFileSync(filename, {
                      encoding: this.svgEncoding
                    })
                  };
                default:
                  throw new SVGTilerException(`Unrecognized extension in filename '${data}' for symbol '${key}'`);
              }
            } else {
              return {
                svg: data
              };
            }
          } else {
            return data;
          }
        }).call(this));
      }
    }

    includes(substring) {
      return this.key.indexOf(substring) >= 0;
    }

  };

  Symbol.svgEncoding = 'utf8';

  Symbol.forceWidth = null; //# default: no size forcing

  Symbol.forceHeight = null; //# default: no size forcing

  Symbol.texText = false;

  /*
  Attempt to render pixels as pixels, as needed for old-school graphics.
  SVG 1.1 and Inkscape define image-rendering="optimizeSpeed" for this.
  Chrome doesn't support this, but supports a CSS3 (or SVG) specification of
  "image-rendering:pixelated".  Combining these seems to work everywhere.
  */
  Symbol.imageRendering = ' image-rendering="optimizeSpeed" style="image-rendering:pixelated"';

  return Symbol;

}).call(this);

//# ECMA6: @key.includes substring
escapeId = function(key) {
  /*
  id/href follows the IRI spec [https://tools.ietf.org/html/rfc3987]:
    ifragment      = *( ipchar / "/" / "?" )
    ipchar         = iunreserved / pct-encoded / sub-delims / ":" / "@"
    iunreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~" / ucschar
    pct-encoded    = "%" HEXDIG HEXDIG
    sub-delims     = "!" / "$" / "&" / "'" / "(" / ")"
                   / "*" / "+" / "," / ";" / "="
    ucschar        = %xA0-D7FF / %xF900-FDCF / #%xFDF0-FFEF
                   / %x10000-1FFFD / %x20000-2FFFD / %x30000-3FFFD
                   / %x40000-4FFFD / %x50000-5FFFD / %x60000-6FFFD
                   / %x70000-7FFFD / %x80000-8FFFD / %x90000-9FFFD
                   / %xA0000-AFFFD / %xB0000-BFFFD / %xC0000-CFFFD
                   / %xD0000-DFFFD / %xE1000-EFFFD
  We also want to escape colon (:) which seems to cause trouble.
  We use encodeURIComponent which escapes everything except
    A-Z a-z 0-9 - _ . ! ~ * ' ( )
  [https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent]
  Unfortunately, Inkscape seems to ignore any %-encoded symbols; see
  https://bugs.launchpad.net/inkscape/+bug/1737778
  So we replace '%' with '$', an allowed character that's already escaped.
  In the special case of a blank key, we use the special $BLANK$ which cannot
  be generated by the escaping process.
  */
  return (encodeURIComponent(key).replace(/%/g, '$')) || '$BLANK$';
};

zeroSizeReplacement = 1;

StaticSymbol = (function() {
  class StaticSymbol extends Symbol {
    constructor(key1, options) {
      var extract, key, overflow, value, warnings;
      super();
      this.key = key1;
      for (key in options) {
        if (!hasProp.call(options, key)) continue;
        value = options[key];
        this[key] = value;
      }
      //# Force SVG namespace when parsing, so nodes have correct namespaceURI.
      //# (This is especially important on the browser, so the results can be
      //# reparented into an HTML Document.)
      this.svg = this.svg.replace(/^\s*<(?:[^<>'"\/]|'[^']*'|"[^"]*")*\s*(\/?\s*>)/, function(match, end) {
        if (indexOf.call(match, 'xmlns') < 0) {
          match = match.slice(0, match.length - end.length) + ` xmlns='${SVGNS}'` + match.slice(match.length - end.length);
        }
        return match;
      });
      this.xml = new DOMParser({
        locator: { //# needed when specifying errorHandler
          line: 1,
          col: 1
        },
        errorHandler: (level, msg, indent = '  ') => {
          msg = msg.replace(/^\[xmldom [^\[\]]*\]\t/, '');
          msg = msg.replace(/@#\[line:(\d+),col:(\d+)\]$/, (match, line, col) => {
            var lines;
            lines = this.svg.split('\n');
            return (line > 1 ? indent + lines[line - 2] + '\n' : '') + indent + lines[line - 1] + '\n' + indent + ' '.repeat(col - 1) + '^^^' + (line < lines.length ? '\n' + indent + lines[line] : '');
          });
          return console.error(`SVG parse \${level} in symbol '${this.key}': ${msg}`);
        }
      }).parseFromString(this.svg, 'image/svg+xml');
      // Remove from the symbol any top-level xmlns=SVGNS possibly added above:
      // we will have such a tag in the top-level <svg>.
      this.xml.documentElement.removeAttribute('xmlns');
      this.viewBox = svgBBox(this.xml);
      this.overflowBox = overflowBox(this.xml);
      overflow = attributeOrStyle(this.xml.documentElement, 'overflow');
      this.overflowVisible = (overflow != null) && /^visible\b/.test(overflow);
      this.width = this.height = null;
      if (this.viewBox != null) {
        this.width = this.viewBox[2];
        this.height = this.viewBox[3];
        /*
        SVG's viewBox has a special rule that "A value of zero [in <width>
        or <height>] disables rendering of the element."  Avoid this.
        [https://www.w3.org/TR/SVG11/coords.html#ViewBoxAttribute]
        */
        if (this.overflowVisible) {
          if (this.width === 0) {
            this.viewBox[2] = zeroSizeReplacement;
          }
          if (this.height === 0) {
            this.viewBox[3] = zeroSizeReplacement;
          }
        }
      }
      if (Symbol.forceWidth != null) {
        this.width = Symbol.forceWidth;
      }
      if (Symbol.forceHeight != null) {
        this.height = Symbol.forceHeight;
      }
      warnings = [];
      if (this.width == null) {
        warnings.push('width');
        this.width = 0;
      }
      if (this.height == null) {
        warnings.push('height');
        this.height = 0;
      }
      if (warnings.length > 0) {
        console.warn(`Failed to detect ${warnings.join(' and ')} of SVG for symbol '${this.key}'`);
      }
      //# Detect special `width="auto"` and/or `height="auto"` fields for future
      //# processing, and remove them to ensure valid SVG.
      this.autoWidth = isAuto(this.xml, 'width');
      this.autoHeight = isAuto(this.xml, 'height');
      if (this.autoWidth) {
        this.xml.documentElement.removeAttribute('width');
      }
      if (this.autoHeight) {
        this.xml.documentElement.removeAttribute('height');
      }
      this.zIndex = zIndex(this.xml.documentElement);
      //# Optionally extract <text> nodes for LaTeX output
      if (Symbol.texText) {
        this.text = [];
        extract = (node) => {
          var child, nextChild, results;
          if (!node.hasChildNodes()) {
            return;
          }
          child = node.lastChild;
          results = [];
          while (child != null) {
            nextChild = child.previousSibling;
            if (child.nodeName === 'text') {
              this.text.push(child);
              node.removeChild(child);
            } else {
              extract(child);
            }
            results.push(child = nextChild);
          }
          return results;
        };
        extract(this.xml.documentElement);
      }
    }

    id() {
      return escapeId(this.key);
    }

    use() {
      return this;
    }

  };

  StaticSymbol.prototype.usesContext = false;

  return StaticSymbol;

}).call(this);

DynamicSymbol = (function() {
  class DynamicSymbol extends Symbol {
    constructor(key1, func, dirname1) {
      super();
      this.key = key1;
      this.func = func;
      this.dirname = dirname1;
      this.versions = {};
      this.nversions = 0;
      this.constructor.all.push(this);
    }

    static resetAll() {
      var k, len, ref, results, symbol;
      ref = this.all;
      //# Resets all DynamicSymbol's versions to 0.
      //# Use before starting a new SVG document.
      results = [];
      for (k = 0, len = ref.length; k < len; k++) {
        symbol = ref[k];
        symbol.versions = {};
        results.push(symbol.nversions = 0);
      }
      return results;
    }

    use(context) {
      var result, string, version;
      result = this.func.call(context);
      if (result == null) {
        throw new Error(`Function for symbol ${this.key} returned ${result}`);
      }
      //# We use JSON serialization to detect duplicate symbols.  This enables
      //# return values like {filename: ...} and JSX virtual dom elements,
      //# in addition to raw SVG strings.
      string = JSON.stringify(result);
      if (!(string in this.versions)) {
        version = this.nversions++;
        this.versions[string] = Symbol.parse(`${this.key}$v${version}`, result, this.dirname);
        this.versions[string].id = () => {
          return `${escapeId(this.key)}$v${version}`;
        };
      }
      return this.versions[string];
    }

  };

  DynamicSymbol.all = [];

  DynamicSymbol.prototype.usesContext = true;

  return DynamicSymbol;

}).call(this);

//# Symbol to fall back to when encountering an unrecognized symbol.
//# Path from https://commons.wikimedia.org/wiki/File:Replacement_character.svg
//# by Amit6, released into the public domain.
unrecognizedSymbol = new StaticSymbol('$UNRECOGNIZED$', {
  svg: `<symbol viewBox="0 0 200 200" preserveAspectRatio="none" width="auto" height="auto">
  <rect width="200" height="200" fill="yellow"/>
  <path xmlns="http://www.w3.org/2000/svg" stroke="none" fill="red" d="M 200,100 100,200 0,100 100,0 200,100 z M 135.64709,74.70585 q 0,-13.52935 -10.00006,-22.52943 -9.99999,-8.99999 -24.35289,-8.99999 -17.29415,0 -30.117661,5.29409 L 69.05879,69.52938 q 9.764731,-6.23528 21.52944,-6.23528 8.82356,0 14.58824,4.82351 5.76469,4.82351 5.76469,12.70589 0,8.5883 -9.94117,21.70588 -9.94117,13.11766 -9.94117,26.76473 l 17.88236,0 q 0,-6.3529 6.9412,-14.9412 11.76471,-14.58816 12.82351,-16.35289 6.9412,-11.05887 6.9412,-23.29417 z m -22.00003,92.11771 0,-24.70585 -27.29412,0 0,24.70585 27.29412,0 z"/>
</symbol>`
});

unrecognizedSymbol.id = function() {
  return '$UNRECOGNIZED$'; // cannot be output of standard id()
};

Input = (function() {
  class Input {
    static parseFile(filename, filedata) {
      var input;
      //# Generic method to parse file once we're already in the right class.
      input = new (this)();
      input.filename = filename;
      if (filedata == null) {
        filedata = fs.readFileSync(filename, {
          encoding: this.encoding
        });
      }
      input.parse(filedata);
      return input;
    }

    static recognize(filename, filedata) {
      var extension;
      //# Recognize type of file and call corresponding class's `parseFile`.
      extension = extensionOf(filename);
      if (extension in extensionMap) {
        return extensionMap[extension].parseFile(filename, filedata);
      } else {
        throw new SVGTilerException(`Unrecognized extension in filename ${filename}`);
      }
    }

  };

  Input.encoding = 'utf8';

  return Input;

}).call(this);

Mapping = class Mapping extends Input {
  load(data) {
    this.map = {};
    if (typeof data === 'function') {
      return this.function = data;
    } else {
      return this.merge(data);
    }
  }

  merge(data) {
    var dirname, key, results, value;
    if (this.filename != null) {
      dirname = path.dirname(this.filename);
    }
    results = [];
    for (key in data) {
      if (!hasProp.call(data, key)) continue;
      value = data[key];
      if (!(value instanceof Symbol)) {
        value = Symbol.parse(key, value, dirname);
      }
      results.push(this.map[key] = value);
    }
    return results;
  }

  lookup(key) {
    var value;
    key = key.toString(); //# Sometimes get a number, e.g., from XLSX
    if (key in this.map) {
      return this.map[key];
    } else if (this.function != null) {
      //# Cache return value of function so that only one Symbol generated
      //# for each key.  It still may be a DynamicSymbol, which will allow
      //# it to make multiple versions, but keep track of which are the same.
      value = this.function(key);
      if (value != null) {
        return this.map[key] = Symbol.parse(key, value);
      } else {
        return value;
      }
    } else {
      return void 0;
    }
  }

};

ASCIIMapping = (function() {
  class ASCIIMapping extends Mapping {
    parse(data) {
      var k, key, len, line, map, ref, separator;
      map = {};
      ref = splitIntoLines(data);
      for (k = 0, len = ref.length; k < len; k++) {
        line = ref[k];
        separator = whitespace.exec(line);
        if (separator == null) {
          continue;
        }
        if (separator.index === 0) {
          if (separator[0].length === 1) {
            //# Single whitespace character at beginning defines blank character
            key = '';
          } else {
            //# Multiple whitespace at beginning defines first whitespace character
            key = line[0];
          }
        } else {
          key = line.slice(0, separator.index);
        }
        map[key] = line.slice(separator.index + separator[0].length);
      }
      return this.load(map);
    }

  };

  ASCIIMapping.title = "ASCII mapping file";

  ASCIIMapping.help = "Each line is <symbol-name><space><raw SVG or filename.svg>";

  return ASCIIMapping;

}).call(this);

JSMapping = (function() {
  class JSMapping extends Mapping {
    parse(data) {
      var __filename, code;
      ({code} = require('@babel/core').transform(data, {
        filename: this.filename,
        plugins: [
          [
            require.resolve('@babel/plugin-transform-react-jsx'),
            {
              useBuiltIns: true,
              pragma: 'preact.h',
              pragmaFrag: 'preact.Fragment',
              throwIfNamespace: false
            }
          ]
        ],
        sourceMaps: 'inline',
        retainLines: true
      }));
      if (0 <= code.indexOf('preact.')) {
        code = `var preact = require('preact'), h = preact.h; ${code}`;
      }
      //# Mimick NodeJS module's __filename and __dirname variables.
      //# Redirect require() to use paths relative to the mapping file.
      //# xxx should probably actually create a NodeJS module when possible
      __filename = path.resolve(this.filename);
      code = `var __filename = ${JSON.stringify(__filename)}, __dirname = ${JSON.stringify(path.dirname(__filename))}, __require = require; require = (module) => __require(module.startsWith('.') ? __require('path').resolve(__dirname, module) : module); ${code}\n//@ sourceURL=${this.filename}`;
      return this.load(eval(code));
    }

  };

  JSMapping.title = "JavaScript mapping file";

  JSMapping.help = "Object mapping symbol names to SYMBOL e.g. dot: 'dot.svg'";

  return JSMapping;

}).call(this);

CoffeeMapping = (function() {
  class CoffeeMapping extends JSMapping {
    parse(data) {
      return super.parse(require('coffeescript').compile(data, {
        bare: true,
        filename: this.filename,
        sourceFiles: [this.filename],
        inlineMap: true
      }));
    }

  };

  CoffeeMapping.title = "CoffeeScript mapping file";

  CoffeeMapping.help = "Object mapping symbol names to SYMBOL e.g. dot: 'dot.svg'";

  return CoffeeMapping;

}).call(this);

//catch err
//  throw err
//  if err.stack? and err.stack.startsWith "#{@filename}:"
//    sourceMap = require('coffeescript').compile(data,
//      bare: true
//      filename: @filename
//      sourceFiles: [@filename]
//      sourceMap: true
//    ).sourceMap
//    err.stack = err.stack.replace /:([0-9]*)/, (m, line) ->
//      ## sourceMap starts line numbers at 0, but we want to work from 1
//      for col in sourceMap?.lines[line-1]?.columns ? [] when col?.sourceLine?
//        unless sourceLine? and sourceLine < col.sourceLine
//          sourceLine = col.sourceLine
//          line = sourceLine + 1
//      ":#{line}"
//  throw err
Mappings = class Mappings {
  constructor(maps = []) {
    this.maps = maps;
  }

  push(map) {
    return this.maps.push(map);
  }

  lookup(key) {
    var i, k, ref, value;
    if (!this.maps.length) {
      return;
    }
    for (i = k = ref = this.maps.length - 1; (ref <= 0 ? k <= 0 : k >= 0); i = ref <= 0 ? ++k : --k) {
      value = this.maps[i].lookup(key);
      if (value != null) {
        return value;
      }
    }
    return void 0;
  }

};

blankCells = {
  '': true,
  ' ': true //# for ASCII art in particular
};

allBlank = function(list) {
  var k, len, x;
  for (k = 0, len = list.length; k < len; k++) {
    x = list[k];
    if ((x != null) && !(x in blankCells)) {
      return false;
    }
  }
  return true;
};

Drawing = class Drawing extends Input {
  load(data) {
    var cell, j, k, l, len, len1, row;
    //# Turn strings into arrays
    data = (function() {
      var k, len, results;
      results = [];
      for (k = 0, len = data.length; k < len; k++) {
        row = data[k];
        results.push((function() {
          var l, len1, results1;
          results1 = [];
          for (l = 0, len1 = row.length; l < len1; l++) {
            cell = row[l];
            results1.push(cell);
          }
          return results1;
        })());
      }
      return results;
    })();
    if (!Drawing.keepMargins) {
      //# Top margin
      while (data.length > 0 && allBlank(data[0])) {
        data.shift();
      }
      //# Bottom margin
      while (data.length > 0 && allBlank(data[data.length - 1])) {
        data.pop();
      }
      if (data.length > 0) {
        //# Left margin
        while (allBlank((function() {
            var l, len1, results;
            results = [];
            for (l = 0, len1 = data.length; l < len1; l++) {
              row = data[l];
              results.push(row[0]);
            }
            return results;
          })())) {
          for (k = 0, len = data.length; k < len; k++) {
            row = data[k];
            row.shift();
          }
        }
        //# Right margin
        j = Math.max(...((function() {
          var l, len1, results;
          results = [];
          for (l = 0, len1 = data.length; l < len1; l++) {
            row = data[l];
            results.push(row.length);
          }
          return results;
        })()));
        while (j >= 0 && allBlank((function() {
            var len2, m, results;
            results = [];
            for (m = 0, len2 = data.length; m < len2; m++) {
              row = data[m];
              results.push(row[j]);
            }
            return results;
          })())) {
          for (l = 0, len1 = data.length; l < len1; l++) {
            row = data[l];
            if (j < row.length) {
              row.pop();
            }
          }
          j--;
        }
      }
    }
    return this.data = data;
  }

  writeSVG(mappings, filename) {
    //# Default filename is the input filename with extension replaced by .svg
    if (filename == null) {
      filename = path.parse(this.filename);
      if (filename.ext === '.svg') {
        filename.base += '.svg';
      } else {
        filename.base = filename.base.slice(0, -filename.ext.length) + '.svg';
      }
      filename = path.format(filename);
    }
    console.log('->', filename);
    fs.writeFileSync(filename, this.renderSVG(mappings));
    return filename;
  }

  renderSVGDOM(mappings) {
    var attribute, cell, child, colWidths, coordsRow, doc, dx, dy, i, j, k, key, l, lastSymbol, len, len1, len2, len3, len4, len5, len6, level, levelOrder, levels, m, missing, n, name, node, o, p, q, ref, ref1, ref2, ref3, ref4, ref5, ref6, ref7, ref8, ref9, row, row2, rowHeight, scaleX, scaleY, svg, symbol, symbolsByKey, use, viewBox, x, y;
    /*
    Main rendering engine, returning an xmldom object for the whole document.
    Also saves the table of symbols in `@symbols`, the corresponding
    coordinates in `@coords`, and overall `@weight` and `@height`,
    for use by `renderTeX`.
    */
    DynamicSymbol.resetAll();
    doc = domImplementation.createDocument(SVGNS, 'svg');
    svg = doc.documentElement;
    svg.setAttribute('xmlns:xlink', XLINKNS);
    svg.setAttribute('version', '1.1');
    //svg.appendChild defs = doc.createElementNS SVGNS, 'defs'
    //# Look up all symbols in the drawing.
    missing = {};
    this.symbols = (function() {
      var k, len, ref, results;
      ref = this.data;
      results = [];
      for (k = 0, len = ref.length; k < len; k++) {
        row = ref[k];
        results.push((function() {
          var l, len1, results1;
          results1 = [];
          for (l = 0, len1 = row.length; l < len1; l++) {
            cell = row[l];
            symbol = mappings.lookup(cell);
            if (symbol != null) {
              results1.push(lastSymbol = symbol);
            } else {
              missing[cell] = true;
              results1.push(unrecognizedSymbol);
            }
          }
          return results1;
        })());
      }
      return results;
    }).call(this);
    missing = (function() {
      var results;
      results = [];
      for (key in missing) {
        if (!hasProp.call(missing, key)) continue;
        results.push(`'${key}'`);
      }
      return results;
    })();
    if (missing.length) {
      console.warn("Failed to recognize symbols:", missing.join(', '));
    }
    //# Instantiate (.use) all (dynamic) symbols in the drawing.
    symbolsByKey = {};
    this.symbols = (function() {
      var k, len, ref, results;
      ref = this.symbols;
      results = [];
      for (i = k = 0, len = ref.length; k < len; i = ++k) {
        row = ref[i];
        results.push((function() {
          var l, len1, results1;
          results1 = [];
          for (j = l = 0, len1 = row.length; l < len1; j = ++l) {
            symbol = row[j];
            if (symbol.usesContext) {
              symbol = symbol.use(new Context(this, i, j));
            } else {
              symbol = symbol.use();
            }
            if (!(symbol.key in symbolsByKey)) {
              symbolsByKey[symbol.key] = symbol;
            } else if (symbolsByKey[symbol.key] === !symbol) {
              console.warn(`Multiple symbols with key ${symbol.key}`);
            }
            results1.push(symbol);
          }
          return results1;
        }).call(this));
      }
      return results;
    }).call(this);
//# Include all used symbols in SVG
    for (key in symbolsByKey) {
      symbol = symbolsByKey[key];
      if (symbol == null) {
        continue;
      }
      svg.appendChild(node = doc.createElementNS(SVGNS, 'symbol'));
      node.setAttribute('id', symbol.id());
      if ((ref = symbol.xml.documentElement.tagName) === 'svg' || ref === 'symbol') {
        ref1 = symbol.xml.documentElement.attributes;
        //# Remove a layer of indirection for <svg> and <symbol>
        for (k = 0, len = ref1.length; k < len; k++) {
          attribute = ref1[k];
          if (!(((ref2 = attribute.name) === 'version' || ref2 === 'id') || attribute.name.slice(0, 5) === 'xmlns')) {
            node.setAttribute(attribute.name, attribute.value);
          }
        }
        ref3 = symbol.xml.documentElement.childNodes;
        for (l = 0, len1 = ref3.length; l < len1; l++) {
          child = ref3[l];
          node.appendChild(child.cloneNode(true));
        }
      } else {
        node.appendChild(symbol.xml.documentElement.cloneNode(true));
      }
      //# Set/overwrite any viewbox attribute with one from symbol.
      if (symbol.viewBox != null) {
        node.setAttribute('viewBox', symbol.viewBox);
      }
    }
    //# Lay out the symbols in the drawing via SVG <use>.
    viewBox = [
      0,
      0,
      0,
      0 //# initially x-min, y-min, x-max, y-max
    ];
    levels = {};
    y = 0;
    colWidths = {};
    this.coords = [];
    ref4 = this.symbols;
    for (i = m = 0, len2 = ref4.length; m < len2; i = ++m) {
      row = ref4[i];
      this.coords.push(coordsRow = []);
      rowHeight = 0;
      for (n = 0, len3 = row.length; n < len3; n++) {
        symbol = row[n];
        if (!symbol.autoHeight) {
          if (symbol.height > rowHeight) {
            rowHeight = symbol.height;
          }
        }
      }
      x = 0;
      for (j = o = 0, len4 = row.length; o < len4; j = ++o) {
        symbol = row[j];
        coordsRow.push({x, y});
        if (symbol == null) {
          continue;
        }
        if (levels[name = symbol.zIndex] == null) {
          levels[name] = [];
        }
        levels[symbol.zIndex].push(use = doc.createElementNS(SVGNS, 'use'));
        use.setAttribute('xlink:href', '#' + symbol.id());
        use.setAttributeNS(SVGNS, 'x', x);
        use.setAttributeNS(SVGNS, 'y', y);
        scaleX = scaleY = 1;
        if (symbol.autoWidth) {
          if (colWidths[j] == null) {
            colWidths[j] = Math.max(0, ...((function() {
              var len5, p, ref5, results;
              ref5 = this.symbols;
              results = [];
              for (p = 0, len5 = ref5.length; p < len5; p++) {
                row2 = ref5[p];
                if ((row2[j] != null) && !row2[j].autoWidth) {
                  results.push(row2[j].width);
                }
              }
              return results;
            }).call(this)));
          }
          if (symbol.width !== 0) {
            scaleX = colWidths[j] / symbol.width;
          }
          if (!symbol.autoHeight) {
            scaleY = scaleX;
          }
        }
        if (symbol.autoHeight) {
          if (symbol.height !== 0) {
            scaleY = rowHeight / symbol.height;
          }
          if (!symbol.autoWidth) {
            scaleX = scaleY;
          }
        }
        //# Scaling of symbol is relative to viewBox, so use that to define
        //# width and height attributes:
        use.setAttributeNS(SVGNS, 'width', ((ref5 = (ref6 = symbol.viewBox) != null ? ref6[2] : void 0) != null ? ref5 : symbol.width) * scaleX);
        use.setAttributeNS(SVGNS, 'height', ((ref7 = (ref8 = symbol.viewBox) != null ? ref8[3] : void 0) != null ? ref7 : symbol.height) * scaleY);
        if (symbol.overflowBox != null) {
          dx = (symbol.overflowBox[0] - symbol.viewBox[0]) * scaleX;
          dy = (symbol.overflowBox[1] - symbol.viewBox[1]) * scaleY;
          viewBox[0] = Math.min(viewBox[0], x + dx);
          viewBox[1] = Math.min(viewBox[1], y + dy);
          viewBox[2] = Math.max(viewBox[2], x + dx + symbol.overflowBox[2] * scaleX);
          viewBox[3] = Math.max(viewBox[3], y + dy + symbol.overflowBox[3] * scaleY);
        }
        x += symbol.width * scaleX;
        viewBox[2] = Math.max(viewBox[2], x);
      }
      y += rowHeight;
      viewBox[3] = Math.max(viewBox[3], y);
    }
    //# Change from x-min, y-min, x-max, y-max to x-min, y-min, width, height
    viewBox[2] = viewBox[2] - viewBox[0];
    viewBox[3] = viewBox[3] - viewBox[1];
    //# Sort by level
    levelOrder = ((function() {
      var results;
      results = [];
      for (level in levels) {
        results.push(level);
      }
      return results;
    })()).sort(function(x, y) {
      return x - y;
    });
    for (p = 0, len5 = levelOrder.length; p < len5; p++) {
      level = levelOrder[p];
      ref9 = levels[level];
      for (q = 0, len6 = ref9.length; q < len6; q++) {
        node = ref9[q];
        svg.appendChild(node);
      }
    }
    svg.setAttributeNS(SVGNS, 'viewBox', viewBox.join(' '));
    svg.setAttributeNS(SVGNS, 'width', this.width = viewBox[2]);
    svg.setAttributeNS(SVGNS, 'height', this.height = viewBox[3]);
    svg.setAttributeNS(SVGNS, 'preserveAspectRatio', 'xMinYMin meet');
    return doc;
  }

  renderSVG(mappings) {
    var out;
    out = new XMLSerializer().serializeToString(this.renderSVGDOM(mappings));
    //# Parsing xlink:href in user's SVG fragments, and then serializing,
    //# can lead to these null namespace definitions.  Remove.
    out = out.replace(/\sxmlns:xlink=""/g, '');
    out = prettyXML(out, {
      newline: '\n' //# force consistent line endings, not require('os').EOL
    });
    return `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
` + out;
  }

  renderTeX(filename) {
    var anchor, basename, child, content, i, j, k, l, len, len1, len2, lines, m, ref, ref1, ref2, ref3, row, symbol, text, tx, ty, wrap, x, y;
    //# Must be called *after* `renderSVG` (or `renderSVGDOM`)
    filename = path.parse(filename);
    basename = filename.base.slice(0, -filename.ext.length);
    //# LaTeX based loosely on Inkscape's PDF/EPS/PS + LaTeX output extension.
    //# See http://tug.ctan.org/tex-archive/info/svg-inkscape/
    lines = [
      `%% Creator: svgtiler ${svgtiler.version}, https://github.com/edemaine/svgtiler
%% This LaTeX file includes and overlays text on top of companion file
%% ${basename}.pdf/.png
%%
%% Instead of \\includegraphics, include this figure via
%%   \\input{${filename.base}}
%% You can scale the image by first defining \\svg{width,height,scale}:
%%   \\def\\svgwidth{\\linewidth} % full width
%% or
%%   \\def\\svgheight{5in}
%% or
%%   \\def\\svgscale{0.5} % 50%
%% (If multiple are specified, the first in the list above takes priority.)
%%
%% If this file resides in another directory from the root .tex file,
%% you need to help it find its auxiliary .pdf/.png file via one of the
%% following options (any one will do):
%%   1. \\usepackage{currfile} so that this file can find its own directory.
%%   2. \\usepackage{import} and \\import{path/to/file/}{${filename.base}}
%%      instead of \\import{${filename.base}}
%%   3. \\graphicspath{{path/to/file/}} % note extra braces and trailing slash
%%
\\begingroup
  \\providecommand\\color[2][]{%
    \\errmessage{You should load package 'color.sty' to render color in svgtiler text.}%
    \\renewcommand\\color[2][]{}%
  }%
  \\ifx\\currfiledir\\undefined
    \\def\\currfiledir{}%
  \\fi
  \\ifx\\svgwidth\\undefined
    \\ifx\\svgheight\\undefined
      \\unitlength=0.75bp\\relax % 1px (SVG unit) = 0.75bp (SVG pts)
      \\ifx\\svgscale\\undefined\\else
        \\ifx\\real\\undefined % in case calc.sty not loaded
          \\unitlength=\\svgscale \\unitlength
        \\else
          \\setlength{\\unitlength}{\\unitlength * \\real{\\svgscale}}%
        \\fi
      \\fi
    \\else
      \\unitlength=\\svgheight
      \\unitlength=${1 / this.height}\\unitlength % divide by image height
    \\fi
  \\else
    \\unitlength=\\svgwidth
    \\unitlength=${1 / this.width}\\unitlength % divide by image width
  \\fi
  \\def\\clap#1{\\hbox to 0pt{\\hss#1\\hss}}%
  \\begin{picture}(${this.width},${this.height})%
    \\put(0,0){\\includegraphics[width=${this.width}\\unitlength]{\\currfiledir ${basename}}}%`
    ];
    ref = this.symbols;
    for (i = k = 0, len = ref.length; k < len; i = ++k) {
      row = ref[i];
      for (j = l = 0, len1 = row.length; l < len1; j = ++l) {
        symbol = row[j];
        ({x, y} = this.coords[i][j]);
        ref1 = symbol.text;
        for (m = 0, len2 = ref1.length; m < len2; m++) {
          text = ref1[m];
          tx = (ref2 = parseNum(text.getAttribute('x'))) != null ? ref2 : 0;
          ty = (ref3 = parseNum(text.getAttribute('y'))) != null ? ref3 : 0;
          content = ((function() {
            var len3, n, ref4, results;
            ref4 = text.childNodes;
            // TEXT_NODE
            results = [];
            for (n = 0, len3 = ref4.length; n < len3; n++) {
              child = ref4[n];
              if (child.nodeType === 3) {
                results.push(child.data);
              }
            }
            return results;
          })()).join('');
          anchor = attributeOrStyle(text, 'text-anchor');
          if (/^middle\b/.test(anchor)) {
            wrap = '\\clap{';
          } else if (/^end\b/.test(anchor)) {
            wrap = '\\rlap{'; //if /^start\b/.test anchor  # default
          } else {
            wrap = '\\llap{';
          }
          // "@height -" is to flip between y down (SVG) and y up (picture)
          lines.push(`    \\put(${x + tx},${this.height - (y + ty)}){\\color{${attributeOrStyle(text, 'fill') || 'black'}}${wrap}${content}${wrap && '}'}}%`);
        }
      }
    }
    lines.push(`  \\end{picture}%
\\endgroup`, ''); // trailing newline
    return lines.join('\n');
  }

  writeTeX(filename) {
    /*
    Must be called *after* `writeSVG`.
    Default filename is the input filename with extension replaced by .svg_tex
    (analogous to .pdf_tex from Inkscape's --export-latex feature, but noting
    that the text is extracted from the SVG not the PDF, and that this file
    works with both .pdf and .png auxiliary files).
    */
    if (filename == null) {
      filename = path.parse(this.filename);
      if (filename.ext === '.svg_tex') {
        filename.base += '.svg_tex';
      } else {
        filename.base = filename.base.slice(0, -filename.ext.length) + '.svg_tex';
      }
      filename = path.format(filename);
    }
    console.log(' &', filename);
    fs.writeFileSync(filename, this.renderTeX(filename));
    return filename;
  }

};

ASCIIDrawing = (function() {
  class ASCIIDrawing extends Drawing {
    parse(data) {
      var line;
      return this.load((function() {
        var k, len, ref, results;
        ref = splitIntoLines(data);
        results = [];
        for (k = 0, len = ref.length; k < len; k++) {
          line = ref[k];
          results.push(graphemeSplitter.splitGraphemes(line));
        }
        return results;
      })());
    }

  };

  ASCIIDrawing.title = "ASCII drawing (one character per symbol)";

  return ASCIIDrawing;

}).call(this);

DSVDrawing = class DSVDrawing extends Drawing {
  parse(data) {
    var ref;
    //# Remove trailing newline / final blank line.
    if (data.slice(-2) === '\r\n') {
      data = data.slice(0, -2);
    } else if ((ref = data.slice(-1)) === '\r' || ref === '\n') {
      data = data.slice(0, -1);
    }
    //# CSV parser.
    return this.load(require('csv-parse/lib/sync')(data, {
      delimiter: this.constructor.delimiter,
      relax_column_count: true
    }));
  }

};

SSVDrawing = (function() {
  class SSVDrawing extends DSVDrawing {
    parse(data) {
      //# Coallesce non-newline whitespace into single space
      return super.parse(data.replace(/[ \t\f\v]+/g, ' '));
    }

  };

  SSVDrawing.title = "Space-delimiter drawing (one word per symbol)";

  SSVDrawing.delimiter = ' ';

  return SSVDrawing;

}).call(this);

CSVDrawing = (function() {
  class CSVDrawing extends DSVDrawing {};

  CSVDrawing.title = "Comma-separated drawing (spreadsheet export)";

  CSVDrawing.delimiter = ',';

  return CSVDrawing;

}).call(this);

TSVDrawing = (function() {
  class TSVDrawing extends DSVDrawing {};

  TSVDrawing.title = "Tab-separated drawing (spreadsheet export)";

  TSVDrawing.delimiter = '\t';

  return TSVDrawing;

}).call(this);

Drawings = (function() {
  class Drawings extends Input {
    load(datas) {
      var data, drawing;
      return this.drawings = (function() {
        var k, len, results;
        results = [];
        for (k = 0, len = datas.length; k < len; k++) {
          data = datas[k];
          drawing = new Drawing();
          drawing.filename = this.filename;
          drawing.subname = data.subname;
          drawing.load(data);
          results.push(drawing);
        }
        return results;
      }).call(this);
    }

    subfilename(extension, drawing) {
      var filename2;
      if (this.drawings.length > 1) {
        filename2 = path.parse(typeof filename !== "undefined" && filename !== null ? filename : this.filename);
        filename2.base = filename2.base.slice(0, -filename2.ext.length);
        filename2.base += this.constructor.filenameSeparator + drawing.subname;
        filename2.base += extension;
        return path.format(filename2);
      } else {
        if (drawing != null) {
          drawing.filename = this.filename; //# use Drawing default if not filename?
        }
        return filename;
      }
    }

    writeSVG(mappings, filename) {
      var drawing, k, len, ref, results;
      ref = this.drawings;
      results = [];
      for (k = 0, len = ref.length; k < len; k++) {
        drawing = ref[k];
        results.push(drawing.writeSVG(mappings, this.subfilename('.svg', drawing)));
      }
      return results;
    }

    writeTeX(filename) {
      var drawing, k, len, ref, results;
      ref = this.drawings;
      results = [];
      for (k = 0, len = ref.length; k < len; k++) {
        drawing = ref[k];
        results.push(drawing.writeTeX(this.subfilename('.svg_tex', drawing)));
      }
      return results;
    }

  };

  Drawings.filenameSeparator = '_';

  return Drawings;

}).call(this);

XLSXDrawings = (function() {
  class XLSXDrawings extends Drawings {
    parse(data) {
      var rows, sheet, sheetInfo, subname, workbook, xlsx;
      xlsx = require('xlsx');
      workbook = xlsx.read(data, {
        type: 'binary'
      });
      //# https://www.npmjs.com/package/xlsx#common-spreadsheet-format
      return this.load((function() {
        var k, len, ref, results;
        ref = workbook.Workbook.Sheets;
        results = [];
        for (k = 0, len = ref.length; k < len; k++) {
          sheetInfo = ref[k];
          subname = sheetInfo.name;
          sheet = workbook.Sheets[subname];
          //# 0 = Visible, 1 = Hidden, 2 = Very Hidden
          //# https://sheetjs.gitbooks.io/docs/#sheet-visibility
          if (sheetInfo.Hidden && !Drawings.keepHidden) {
            continue;
          }
          if (subname.length === 31) {
            console.warn(`Warning: Sheet '${subname}' has length exactly 31, which may be caused by Google Sheets export truncation`);
          }
          rows = xlsx.utils.sheet_to_json(sheet, {
            header: 1,
            defval: ''
          });
          rows.subname = subname;
          results.push(rows);
        }
        return results;
      })());
    }

  };

  XLSXDrawings.encoding = 'binary';

  XLSXDrawings.title = "Spreadsheet drawing(s) (Excel/OpenDocument/Lotus/dBASE)";

  return XLSXDrawings;

}).call(this);

Context = class Context {
  constructor(drawing1, i1, j1) {
    var ref, ref1;
    this.drawing = drawing1;
    this.i = i1;
    this.j = j1;
    this.symbols = this.drawing.symbols;
    this.filename = this.drawing.filename;
    this.subname = this.drawing.subname;
    this.symbol = (ref = this.symbols[this.i]) != null ? ref[this.j] : void 0;
    this.key = (ref1 = this.symbol) != null ? ref1.key : void 0;
  }

  neighbor(dj, di) {
    return new Context(this.drawing, this.i + di, this.j + dj);
  }

  includes(...args) {
    return (this.symbol != null) && this.symbol.includes(...args);
  }

  row(di = 0) {
    var i, j, k, len, ref, ref1, results, symbol;
    i = this.i + di;
    ref1 = (ref = this.symbols[i]) != null ? ref : [];
    results = [];
    for (j = k = 0, len = ref1.length; k < len; j = ++k) {
      symbol = ref1[j];
      results.push(new Context(this.drawing, i, j));
    }
    return results;
  }

  column(dj = 0) {
    var i, j, k, len, ref, results, row;
    j = this.j + dj;
    ref = this.symbols;
    results = [];
    for (i = k = 0, len = ref.length; k < len; i = ++k) {
      row = ref[i];
      results.push(new Context(this.drawing, i, j));
    }
    return results;
  }

};

extensionMap = {
  '.txt': ASCIIMapping,
  '.js': JSMapping,
  '.jsx': JSMapping,
  '.coffee': CoffeeMapping,
  '.cjsx': CoffeeMapping,
  '.asc': ASCIIDrawing,
  '.ssv': SSVDrawing,
  '.csv': CSVDrawing,
  '.tsv': TSVDrawing,
  //# Parsable by xlsx package:
  '.xlsx': XLSXDrawings, //# Excel 2007+ XML Format
  '.xlsm': XLSXDrawings, //# Excel 2007+ Macro XML Format
  '.xlsb': XLSXDrawings, //# Excel 2007+ Binary Format
  '.xls': XLSXDrawings, //# Excel 2.0 or 2003-2004 (SpreadsheetML)
  '.ods': XLSXDrawings, //# OpenDocument Spreadsheet
  '.fods': XLSXDrawings, //# Flat OpenDocument Spreadsheet
  '.dif': XLSXDrawings, //# Data Interchange Format (DIF)
  '.prn': XLSXDrawings, //# Lotus Formatted Text
  '.dbf': XLSXDrawings //# dBASE II/III/IV / Visual FoxPro
};

sanitize = true;

bufferSize = 16 * 1024;

postprocess = function(format, filename) {
  var buffer, e, file, fileSize, match, position, readSize, string;
  if (!sanitize) {
    return;
  }
  try {
    switch (format) {
      case 'pdf':
        //# Blank out /CreationDate in PDF for easier version control.
        //# Replace these commands with spaces to avoid in-file pointer errors.
        buffer = Buffer.alloc(bufferSize);
        fileSize = fs.statSync(filename).size;
        position = Math.max(0, fileSize - bufferSize);
        file = fs.openSync(filename, 'r+');
        readSize = fs.readSync(file, buffer, 0, bufferSize, position);
        string = buffer.toString('binary'); //# must use single-byte encoding!
        match = /\/CreationDate\s*\((?:[^()\\]|\\[^])*\)/.exec(string);
        if (match != null) {
          fs.writeSync(file, ' '.repeat(match[0].length), position + match.index);
        }
        return fs.closeSync(file);
    }
  } catch (error1) {
    e = error1;
    return console.log(`Failed to postprocess '${filename}': ${e}`);
  }
};

convertSVG = function(format, svg, sync) {
  var args, child_process, filename, output, preprocess, result;
  child_process = require('child_process');
  filename = path.parse(svg);
  if (filename.ext === `.${format}`) {
    filename.base += `.${format}`;
  } else {
    filename.base = `${filename.base.slice(0, -filename.ext.length)}.${format}`;
  }
  output = path.format(filename);
  //# Workaround relative paths not working in MacOS distribution of Inkscape
  //# [https://bugs.launchpad.net/inkscape/+bug/181639]
  if (process.platform === 'darwin') {
    preprocess = path.resolve;
  } else {
    preprocess = function(x) {
      return x;
    };
  }
  args = ['-z', `--file=${preprocess(svg)}`, `--export-${format}=${preprocess(output)}`];
  if (sync) {
    //# In sychronous mode, we let inkscape directly output its error messages,
    //# and add warnings about any failures that occur.
    console.log('=>', output);
    result = child_process.spawnSync('inkscape', args, {
      stdio: 'inherit'
    });
    if (result.error) {
      return console.log(result.error.message);
    } else if (result.status || result.signal) {
      return console.log(`:-( ${output} FAILED`);
    } else {
      return postprocess(format, output);
    }
  } else {
    //# In asychronous mode, we capture inkscape's outputs, and print them only
    //# when the process has finished, along with which file failed, to avoid
    //# mixing up messages from parallel executions.
    return function(resolve) {
      var inkscape, out;
      console.log('=>', output);
      inkscape = require('child_process').spawn('inkscape', args);
      out = '';
      inkscape.stdout.on('data', function(buf) {
        return out += buf;
      });
      inkscape.stderr.on('data', function(buf) {
        return out += buf;
      });
      inkscape.on('error', function(error) {
        return console.log(error.message);
      });
      return inkscape.on('exit', function(status, signal) {
        if (status || signal) {
          console.log(`:-( ${output} FAILED:`);
          console.log(out);
        } else {
          postprocess(format, output);
        }
        return resolve();
      });
    };
  }
};

help = function() {
  var extension, klass, ref;
  console.log(`svgtiler ${(ref = svgtiler.version) != null ? ref : "(web)"}
Usage: ${process.argv[1]} (...options and filenames...)
Documentation: https://github.com/edemaine/svgtiler

Optional arguments:
  --help                Show this help message and exit.
  -m / --margin         Don't delete blank extreme rows/columns
  --hidden              Process hidden sheets within spreadsheet files
  --tw TILE_WIDTH / --tile-width TILE_WIDTH
                        Force all symbol tiles to have specified width
  --th TILE_HEIGHT / --tile-height TILE_HEIGHT
                        Force all symbol tiles to have specified height
  -p / --pdf            Convert output SVG files to PDF via Inkscape
  -P / --png            Convert output SVG files to PNG via Inkscape
  -t / --tex            Move <text> from SVG to accompanying LaTeX file.tex
  --no-sanitize         Don't sanitize PDF output by blanking out /CreationDate
  -j N / --jobs N       Run up to N Inkscape jobs in parallel

Filename arguments:  (mappings before drawings!)
`);
  for (extension in extensionMap) {
    klass = extensionMap[extension];
    if (extension.length < 10) {
      extension += ' '.repeat(10 - extension.length);
    }
    console.log(`  *${extension}  ${klass.title}`);
    if (klass.help != null) {
      console.log(`               ${klass.help}`);
    }
  }
  console.log(`
SYMBOL specifiers:  (omit the quotes in anything except .js and .coffee files)

  'filename.svg':   load SVG from specified file
  'filename.png':   include PNG image from specified file
  'filename.jpg':   include JPEG image from specified file
  '<svg>...</svg>': raw SVG
  -> ...@key...:    function computing SVG, with \`this\` bound to Context with
                    \`key\` (symbol name), \`i\` and \`j\` (y and x coordinates),
                    \`filename\` (drawing filename), \`subname\` (subsheet name),
                    and supporting \`neighbor\`/\`includes\`/\`row\`/\`column\` methods`);
  //object with one or more attributes
  return process.exit();
};

main = function() {
  var arg, args, filename, filenames, files, format, formats, i, input, jobs, k, l, len, len1, len2, m, mappings, skip, sync;
  mappings = new Mappings();
  args = process.argv.slice(2);
  files = skip = 0;
  formats = [];
  jobs = [];
  sync = true;
  for (i = k = 0, len = args.length; k < len; i = ++k) {
    arg = args[i];
    if (skip) {
      skip--;
      continue;
    }
    switch (arg) {
      case '-h':
      case '--help':
        help();
        break;
      case '-m':
      case '--margin':
        Drawing.keepMargins = true;
        break;
      case '--hidden':
        Drawings.keepHidden = true;
        break;
      case '--tw':
      case '--tile-width':
        skip = 1;
        arg = parseFloat(args[i + 1]);
        if (arg) {
          Symbol.forceWidth = arg;
        } else {
          console.warn(`Invalid argument to --tile-width: ${args[i + 1]}`);
        }
        break;
      case '--th':
      case '--tile-height':
        skip = 1;
        arg = parseFloat(args[i + 1]);
        if (arg) {
          Symbol.forceHeight = arg;
        } else {
          console.warn(`Invalid argument to --tile-height: ${args[i + 1]}`);
        }
        break;
      case '-p':
      case '--pdf':
        formats.push('pdf');
        break;
      case '-P':
      case '--png':
        formats.push('png');
        break;
      case '-t':
      case '--tex':
        Symbol.texText = true;
        break;
      case '--no-sanitize':
        sanitize = false;
        break;
      case '-j':
      case '--jobs':
        skip = 1;
        arg = parseInt(args[i + 1]);
        if (arg) {
          jobs = new require('async-limiter')({
            concurrency: arg
          });
          sync = false;
        } else {
          console.warn(`Invalid argument to --jobs: ${args[i + 1]}`);
        }
        break;
      default:
        files++;
        console.log('*', arg);
        input = Input.recognize(arg);
        if (input instanceof Mapping) {
          mappings.push(input);
        } else if (input instanceof Drawing || input instanceof Drawings) {
          filenames = input.writeSVG(mappings);
          if (Symbol.texText) {
            input.writeTeX(mappings);
          }
          for (l = 0, len1 = formats.length; l < len1; l++) {
            format = formats[l];
            if (typeof filenames === 'string') {
              jobs.push(convertSVG(format, filenames, sync));
            } else {
              for (m = 0, len2 = filenames.length; m < len2; m++) {
                filename = filenames[m];
                jobs.push(convertSVG(format, filename, sync));
              }
            }
          }
        }
    }
  }
  if (!files) {
    console.log('Not enough filename arguments');
    return help();
  }
};

exports = {Symbol, StaticSymbol, DynamicSymbol, unrecognizedSymbol, Mapping, ASCIIMapping, JSMapping, CoffeeMapping, Drawing, ASCIIDrawing, DSVDrawing, SSVDrawing, CSVDrawing, TSVDrawing, Drawings, XLSXDrawings, Input, Mappings, Context, SVGTilerException, SVGNS, XLINKNS, main};

if (typeof module !== "undefined" && module !== null) {
  if (module.exports == null) {
    module.exports = exports;
  }
}

if (typeof window !== "undefined" && window !== null) {
  if (window.svgtiler == null) {
    window.svgtiler = exports;
  }
}

if (typeof window === "undefined" || window === null) {
  main();
}

}).call(this);