@jbrowse/core 1.6.8 → 1.7.1

package/util/offscreenCanvas/Canvas2DContextShim/context.js

@@ -0,0 +1,356 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.replayCommandsOntoContext = replayCommandsOntoContext;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _svg = require("./svg");
+
+var _types = require("./types");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+/** decode all the commands in the given buffer and replay them onto the given context */
+function replayCommandsOntoContext(targetContext, encodedCommands) {
+  var _iterator = _createForOfIteratorHelper(encodedCommands),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var command = _step.value;
+
+      if ((0, _types.isMethodCall)(command)) {
+        // @ts-ignore
+        // eslint-disable-next-line prefer-spread
+        targetContext[command.name].apply(targetContext, command.args);
+      } else {
+        // @ts-ignore
+        targetContext[command.name] = command.args[0];
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+var OffscreenCanvasRenderingContext2DShim = /*#__PURE__*/function () {
+  function OffscreenCanvasRenderingContext2DShim(width, height) {
+    (0, _classCallCheck2.default)(this, OffscreenCanvasRenderingContext2DShim);
+    (0, _defineProperty2.default)(this, "width", void 0);
+    (0, _defineProperty2.default)(this, "height", void 0);
+    (0, _defineProperty2.default)(this, "currentFont", '12px Courier New, monospace');
+    (0, _defineProperty2.default)(this, "currentStrokeStyle", '');
+    (0, _defineProperty2.default)(this, "currentFillStyle", '');
+    (0, _defineProperty2.default)(this, "recordedCommands", []);
+    this.width = width;
+    this.height = height;
+  }
+
+  (0, _createClass2.default)(OffscreenCanvasRenderingContext2DShim, [{
+    key: "pushMethodCall",
+    value: function pushMethodCall(name, args) {
+      this.recordedCommands.push({
+        name: name,
+        args: args
+      });
+    }
+  }, {
+    key: "pushSetterCall",
+    value: function pushSetterCall(name, arg) {
+      this.recordedCommands.push({
+        name: name,
+        args: [arg]
+      });
+    }
+  }, {
+    key: "getSerializedCommands",
+    value: function getSerializedCommands() {
+      return this.recordedCommands;
+    }
+  }, {
+    key: "getSerializedSvg",
+    value: function getSerializedSvg() {
+      return (0, _svg.getSerializedSvg)(this);
+    }
+  }, {
+    key: "getCommands",
+    value: function getCommands() {
+      return this.recordedCommands;
+    } // setters (no getters working)
+
+  }, {
+    key: "strokeStyle",
+    set: function set(style) {
+      if (style !== this.currentStrokeStyle) {
+        this.pushSetterCall('strokeStyle', style);
+        this.currentStrokeStyle = style;
+      }
+    }
+  }, {
+    key: "fillStyle",
+    set: function set(style) {
+      if (style !== this.currentFillStyle) {
+        this.pushSetterCall('fillStyle', style);
+        this.currentFillStyle = style;
+      }
+    }
+  }, {
+    key: "font",
+    set: function set(style) {
+      this.currentFont = style;
+      this.pushSetterCall('font', style);
+    } // methods
+
+  }, {
+    key: "arc",
+    value: function arc() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      this.pushMethodCall('arc', args);
+    }
+  }, {
+    key: "arcTo",
+    value: function arcTo() {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      this.pushMethodCall('arcTo', args);
+    }
+  }, {
+    key: "beginPath",
+    value: function beginPath() {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+
+      this.pushMethodCall('beginPath', args);
+    }
+  }, {
+    key: "clearRect",
+    value: function clearRect() {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+
+      this.pushMethodCall('clearRect', args);
+    }
+  }, {
+    key: "closePath",
+    value: function closePath() {
+      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+        args[_key5] = arguments[_key5];
+      }
+
+      this.pushMethodCall('closePath', args);
+    }
+  }, {
+    key: "ellipse",
+    value: function ellipse() {
+      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+        args[_key6] = arguments[_key6];
+      }
+
+      this.pushMethodCall('ellipse', args);
+    }
+  }, {
+    key: "fill",
+    value: function fill() {
+      for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+        args[_key7] = arguments[_key7];
+      }
+
+      this.pushMethodCall('fill', args);
+    }
+  }, {
+    key: "fillRect",
+    value: function fillRect() {
+      for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+        args[_key8] = arguments[_key8];
+      }
+
+      var x = args[0],
+          y = args[1],
+          w = args[2],
+          h = args[3];
+
+      if (x > this.width || x + w < 0) {
+        return;
+      }
+
+      var nx = Math.max(x, 0);
+      var nw = w - (nx - x);
+      this.pushMethodCall('fillRect', [nx, y, nw, h]);
+    }
+  }, {
+    key: "fillText",
+    value: function fillText() {
+      for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+        args[_key9] = arguments[_key9];
+      }
+
+      // if (x > this.width || x + 1000 < 0) {
+      //   return
+      // }
+      this.pushMethodCall('fillText', args);
+    }
+  }, {
+    key: "lineTo",
+    value: function lineTo() {
+      for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
+        args[_key10] = arguments[_key10];
+      }
+
+      this.pushMethodCall('lineTo', args);
+    }
+  }, {
+    key: "measureText",
+    value: function measureText() {
+      for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
+        args[_key11] = arguments[_key11];
+      }
+
+      var text = args[0];
+      var height = Number((this.currentFont.match(/\d+/) || [])[0]);
+      return {
+        width: height / 2 * text.length,
+        height: height
+      };
+    }
+  }, {
+    key: "moveTo",
+    value: function moveTo() {
+      for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
+        args[_key12] = arguments[_key12];
+      }
+
+      this.pushMethodCall('moveTo', args);
+    }
+  }, {
+    key: "quadraticCurveTo",
+    value: function quadraticCurveTo() {
+      for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
+        args[_key13] = arguments[_key13];
+      }
+
+      this.pushMethodCall('quadraticCurveTo', args);
+    }
+  }, {
+    key: "rect",
+    value: function rect() {
+      for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
+        args[_key14] = arguments[_key14];
+      }
+
+      this.pushMethodCall('rect', args);
+    }
+  }, {
+    key: "restore",
+    value: function restore() {
+      for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
+        args[_key15] = arguments[_key15];
+      }
+
+      this.pushMethodCall('restore', args);
+    }
+  }, {
+    key: "rotate",
+    value: function rotate() {
+      for (var _len16 = arguments.length, args = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {
+        args[_key16] = arguments[_key16];
+      }
+
+      this.pushMethodCall('rotate', args);
+    }
+  }, {
+    key: "save",
+    value: function save() {
+      for (var _len17 = arguments.length, args = new Array(_len17), _key17 = 0; _key17 < _len17; _key17++) {
+        args[_key17] = arguments[_key17];
+      }
+
+      this.pushMethodCall('save', args);
+    }
+  }, {
+    key: "setTransform",
+    value: function setTransform() {
+      for (var _len18 = arguments.length, args = new Array(_len18), _key18 = 0; _key18 < _len18; _key18++) {
+        args[_key18] = arguments[_key18];
+      }
+
+      this.pushMethodCall('setTransform', args);
+    }
+  }, {
+    key: "scale",
+    value: function scale() {
+      for (var _len19 = arguments.length, args = new Array(_len19), _key19 = 0; _key19 < _len19; _key19++) {
+        args[_key19] = arguments[_key19];
+      }
+
+      this.pushMethodCall('scale', args);
+    } //* shim does not support passing a Path2D object */
+
+  }, {
+    key: "stroke",
+    value: function stroke() {
+      this.pushMethodCall('stroke', []);
+    }
+  }, {
+    key: "strokeRect",
+    value: function strokeRect() {
+      for (var _len20 = arguments.length, args = new Array(_len20), _key20 = 0; _key20 < _len20; _key20++) {
+        args[_key20] = arguments[_key20];
+      }
+
+      this.pushMethodCall('strokeRect', args);
+    }
+  }, {
+    key: "strokeText",
+    value: function strokeText() {
+      for (var _len21 = arguments.length, args = new Array(_len21), _key21 = 0; _key21 < _len21; _key21++) {
+        args[_key21] = arguments[_key21];
+      }
+
+      this.pushMethodCall('strokeText', args);
+    }
+  }, {
+    key: "transform",
+    value: function transform() {
+      for (var _len22 = arguments.length, args = new Array(_len22), _key22 = 0; _key22 < _len22; _key22++) {
+        args[_key22] = arguments[_key22];
+      }
+
+      this.pushMethodCall('transform', args);
+    }
+  }, {
+    key: "translate",
+    value: function translate() {
+      for (var _len23 = arguments.length, args = new Array(_len23), _key23 = 0; _key23 < _len23; _key23++) {
+        args[_key23] = arguments[_key23];
+      }
+
+      this.pushMethodCall('translate', args);
+    }
+  }]);
+  return OffscreenCanvasRenderingContext2DShim;
+}();
+
+exports.default = OffscreenCanvasRenderingContext2DShim;

package/util/offscreenCanvas/Canvas2DContextShim/index.d.ts

@@ -0,0 +1,2 @@
+import ctx from './context';
+export default ctx;

package/util/offscreenCanvas/Canvas2DContextShim/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _context = _interopRequireDefault(require("./context"));
+
+var _default = _context.default;
+exports.default = _default;

package/util/offscreenCanvas/Canvas2DContextShim/svg.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import Canvas2DContextShim from '.';
+export declare function getSerializedSvg(ctx: Canvas2DContextShim): JSX.Element;

package/util/offscreenCanvas/Canvas2DContextShim/svg.js

@@ -0,0 +1,210 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSerializedSvg = getSerializedSvg;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _svgPathGenerator = _interopRequireDefault(require("svg-path-generator"));
+
+var _util = require("./util");
+
+var _types = require("./types");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function getSerializedSvg(ctx) {
+  var currentFill;
+  var currentStroke;
+  var currentPath = [];
+  var rotation;
+  var font;
+  var nodes = [];
+  var index = 0;
+
+  var _iterator = _createForOfIteratorHelper(ctx.getCommands()),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var command = _step.value;
+
+      if ((0, _types.isSetterCall)(command)) {
+        if (command.name === 'font') {
+          if (command.args) {
+            // stackoverflow.com/questions/5618676
+            // skip lineHeight in the final usage
+            var _parseFont = (0, _util.parseFont)(command.args[0]),
+                fontStyle = _parseFont.fontStyle,
+                fontFamily = _parseFont.fontFamily,
+                fontSize = _parseFont.fontSize;
+
+            font = {
+              fontStyle: fontStyle,
+              fontFamily: fontFamily,
+              fontSize: fontSize
+            };
+          }
+        }
+
+        if (command.name === 'fillStyle') {
+          if (command.args) {
+            currentFill = command.args[0];
+          }
+        }
+
+        if (command.name === 'strokeStyle') {
+          if (command.args) {
+            currentStroke = command.args[0];
+          }
+        }
+      } else if ((0, _types.isMethodCall)(command)) {
+        if (command.name === 'fillRect') {
+          var _ref = command.args,
+              _ref2 = (0, _slicedToArray2.default)(_ref, 4),
+              x = _ref2[0],
+              y = _ref2[1],
+              w = _ref2[2],
+              h = _ref2[3];
+
+          var _splitColor = (0, _util.splitColor)(currentFill),
+              hex = _splitColor.hex,
+              opacity = _splitColor.opacity;
+
+          var ny = Math.min(y, y + h);
+          var nh = Math.abs(h);
+          nodes.push( /*#__PURE__*/_react.default.createElement("rect", {
+            key: index,
+            fill: hex,
+            fillOpacity: opacity !== 1 ? opacity : undefined,
+            x: x.toFixed(3),
+            y: ny.toFixed(3),
+            width: w.toFixed(3),
+            height: nh.toFixed(3)
+          }));
+        }
+
+        if (command.name === 'fillText') {
+          var _ref3 = command.args,
+              _ref4 = (0, _slicedToArray2.default)(_ref3, 3),
+              text = _ref4[0],
+              _x = _ref4[1],
+              _y = _ref4[2];
+
+          var _splitColor2 = (0, _util.splitColor)(currentFill),
+              _hex = _splitColor2.hex,
+              _opacity = _splitColor2.opacity;
+
+          nodes.push( /*#__PURE__*/_react.default.createElement("text", (0, _extends2.default)({
+            key: index,
+            fill: _hex,
+            fillOpacity: _opacity !== 1 ? _opacity : undefined,
+            x: _x.toFixed(3),
+            y: _y.toFixed(3)
+          }, font), text));
+        }
+
+        if (command.name === 'beginPath') {
+          currentPath = [];
+        }
+
+        if (command.name === 'moveTo') {
+          currentPath.push(command.args);
+        }
+
+        if (command.name === 'lineTo') {
+          currentPath.push(command.args);
+        }
+
+        if (command.name === 'closePath') {
+          /* do nothing */
+        }
+
+        if (command.name === 'fill') {
+          var _Path;
+
+          var path = (_Path = (0, _svgPathGenerator.default)()).moveTo.apply(_Path, (0, _toConsumableArray2.default)(currentPath[0]));
+
+          for (var i = 1; i < currentPath.length; i++) {
+            var _path;
+
+            path = (_path = path).lineTo.apply(_path, (0, _toConsumableArray2.default)(currentPath[i]));
+          }
+
+          path.end();
+
+          var _splitColor3 = (0, _util.splitColor)(currentFill),
+              _hex2 = _splitColor3.hex,
+              _opacity2 = _splitColor3.opacity;
+
+          nodes.push( /*#__PURE__*/_react.default.createElement("path", {
+            key: index,
+            fill: _hex2,
+            d: path,
+            fillOpacity: _opacity2 !== 1 ? _opacity2 : undefined
+          }));
+        }
+
+        if (command.name === 'stroke') {
+          var _Path2;
+
+          var _path2 = (_Path2 = (0, _svgPathGenerator.default)()).moveTo.apply(_Path2, (0, _toConsumableArray2.default)(currentPath[0]));
+
+          for (var _i = 1; _i < currentPath.length; _i++) {
+            var _path3;
+
+            _path2 = (_path3 = _path2).lineTo.apply(_path3, (0, _toConsumableArray2.default)(currentPath[_i]));
+          }
+
+          _path2.end();
+
+          var _splitColor4 = (0, _util.splitColor)(currentStroke),
+              _hex3 = _splitColor4.hex,
+              _opacity3 = _splitColor4.opacity;
+
+          nodes.push( /*#__PURE__*/_react.default.createElement("path", {
+            key: index,
+            fill: "none",
+            stroke: _hex3,
+            fillOpacity: _opacity3 !== 1 ? _opacity3 : undefined,
+            d: _path2
+          }));
+        }
+
+        if (command.name === 'rotate') {
+          var _ref5 = command.args,
+              _ref6 = (0, _slicedToArray2.default)(_ref5, 1),
+              radians = _ref6[0];
+
+          rotation = radians * 180 / Math.PI;
+        }
+      } else {
+        throw new Error('invalid call');
+      }
+
+      index++;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return rotation ? /*#__PURE__*/_react.default.createElement("g", {
+    transform: "rotate(".concat(rotation, ")")
+  }, [].concat(nodes)) : /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, [].concat(nodes));
+}

package/util/offscreenCanvas/Canvas2DContextShim/types.d.ts

@@ -0,0 +1,50 @@
+export interface Command {
+    name: string;
+    args: unknown[];
+}
+export declare enum CallSchemaField {
+    STRING = 0,
+    FLOAT = 1,
+    BOOL = 2,
+    FOLLOWING_ARGUMENTS_OPTIONAL = 3
+}
+export declare const setterDataTypes: {
+    strokeStyle: CallSchemaField[];
+    font: CallSchemaField[];
+    fillStyle: CallSchemaField[];
+};
+export declare const methodSignatures: {
+    arc: CallSchemaField[];
+    arcTo: CallSchemaField[];
+    beginPath: never[];
+    clearRect: CallSchemaField[];
+    closePath: never[];
+    ellipse: CallSchemaField[];
+    fill: CallSchemaField[];
+    fillRect: CallSchemaField[];
+    fillText: CallSchemaField[];
+    lineTo: CallSchemaField[];
+    moveTo: CallSchemaField[];
+    quadraticCurveTo: CallSchemaField[];
+    rect: CallSchemaField[];
+    restore: never[];
+    rotate: CallSchemaField[];
+    save: never[];
+    setTransform: CallSchemaField[];
+    scale: CallSchemaField[];
+    stroke: never[];
+    strokeRect: CallSchemaField[];
+    strokeText: CallSchemaField[];
+    transform: CallSchemaField[];
+    translate: CallSchemaField[];
+};
+export declare type SetterName = keyof typeof setterDataTypes;
+export declare type MethodName = keyof typeof methodSignatures;
+export interface SetterCall extends Command {
+    name: SetterName;
+}
+export interface MethodCall extends Command {
+    name: MethodName;
+}
+export declare function isMethodCall(call: Command): call is MethodCall;
+export declare function isSetterCall(call: Command): call is SetterCall;

package/util/offscreenCanvas/Canvas2DContextShim/types.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CallSchemaField = void 0;
+exports.isMethodCall = isMethodCall;
+exports.isSetterCall = isSetterCall;
+exports.setterDataTypes = exports.methodSignatures = void 0;
+var CallSchemaField;
+exports.CallSchemaField = CallSchemaField;
+
+(function (CallSchemaField) {
+  CallSchemaField[CallSchemaField["STRING"] = 0] = "STRING";
+  CallSchemaField[CallSchemaField["FLOAT"] = 1] = "FLOAT";
+  CallSchemaField[CallSchemaField["BOOL"] = 2] = "BOOL";
+  CallSchemaField[CallSchemaField["FOLLOWING_ARGUMENTS_OPTIONAL"] = 3] = "FOLLOWING_ARGUMENTS_OPTIONAL";
+})(CallSchemaField || (exports.CallSchemaField = CallSchemaField = {}));
+
+var setterDataTypes = {
+  strokeStyle: [CallSchemaField.FOLLOWING_ARGUMENTS_OPTIONAL, CallSchemaField.STRING],
+  font: [CallSchemaField.FOLLOWING_ARGUMENTS_OPTIONAL, CallSchemaField.STRING],
+  fillStyle: [CallSchemaField.FOLLOWING_ARGUMENTS_OPTIONAL, CallSchemaField.STRING]
+};
+exports.setterDataTypes = setterDataTypes;
+var methodSignatures = {
+  arc: [CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FOLLOWING_ARGUMENTS_OPTIONAL, CallSchemaField.BOOL],
+  arcTo: [CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  beginPath: [],
+  clearRect: [CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  closePath: [],
+  ellipse: [CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FOLLOWING_ARGUMENTS_OPTIONAL, CallSchemaField.BOOL],
+  fill: [CallSchemaField.FOLLOWING_ARGUMENTS_OPTIONAL, CallSchemaField.STRING],
+  fillRect: [CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  fillText: [CallSchemaField.STRING, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FOLLOWING_ARGUMENTS_OPTIONAL, CallSchemaField.FLOAT],
+  lineTo: [CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  moveTo: [CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  quadraticCurveTo: [CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  rect: [CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  restore: [],
+  rotate: [CallSchemaField.FLOAT],
+  save: [],
+  setTransform: [CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  scale: [CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  stroke: [],
+  strokeRect: [CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  strokeText: [CallSchemaField.STRING, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FOLLOWING_ARGUMENTS_OPTIONAL, CallSchemaField.FLOAT],
+  transform: [CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT, CallSchemaField.FLOAT],
+  translate: [CallSchemaField.FLOAT, CallSchemaField.FLOAT]
+};
+exports.methodSignatures = methodSignatures;
+
+function isMethodCall(call) {
+  return Boolean(call.name in methodSignatures);
+}
+
+function isSetterCall(call) {
+  return Boolean(call.name in setterDataTypes);
+}