@jbrowse/core 1.7.8 → 1.7.9

package/ui/SanitizedHTML.js

@@ -2,24 +2,32 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
+var _typeof = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = SanitizedHTML;
 exports.isHTML = isHTML;
 
-var _react = _interopRequireDefault(require("react"));
+var _react = _interopRequireWildcard(require("react"));
 
 var _escapeHtml = _interopRequireDefault(require("escape-html"));
 
 var _dompurify = _interopRequireDefault(require("dompurify"));
 
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 // source https://github.com/sindresorhus/html-tags/blob/master/html-tags.json
 // with some random uncommon ones removed. note: we just use this to run the content
 // through dompurify without escaping if we see an htmlTag from this list
 // otherwise we escape angle brackets and things prematurely because it might be
 // something like <TRA> in VCF. Ref #657
-var htmlTags = ['a', 'b', 'br', 'code', 'div', 'em', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'i', 'img', 'li', 'p', 'pre', 'span', 'small', 'strong', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'tr', 'u', 'ul']; // adapted from is-html https://github.com/sindresorhus/is-html/blob/master/index.js
+var htmlTags = ['a', 'b', 'br', 'code', 'div', 'em', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'i', 'img', 'li', 'p', 'pre', 'span', 'small', 'strong', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'tr', 'u', 'ul'];
+var added = false; // adapted from is-html
+// https://github.com/sindresorhus/is-html/blob/master/index.js
 
 var full = new RegExp(htmlTags.map(function (tag) {
   return "<".concat(tag, "\\b[^>]*>");
@@ -31,9 +39,23 @@ function isHTML(str) {
 
 function SanitizedHTML(_ref) {
   var html = _ref.html;
-  var value = isHTML(html) ? html : (0, _escapeHtml.default)(html); // eslint-disable-next-line react/no-danger
-
+  var value = isHTML(html) ? html : (0, _escapeHtml.default)(html);
+  (0, _react.useEffect)(function () {
+    if (!added) {
+      added = true; // see https://github.com/cure53/DOMPurify/issues/317
+      // only have to add this once, and can't do it globally because dompurify
+      // not yet initialized at global scope
+
+      _dompurify.default.addHook('afterSanitizeAttributes', function (node) {
+        if (node.tagName === 'A') {
+          node.setAttribute('rel', 'noopener noreferrer');
+          node.setAttribute('target', '_blank');
+        }
+      });
+    }
+  }, []);
   return /*#__PURE__*/_react.default.createElement("div", {
+    // eslint-disable-next-line react/no-danger
     dangerouslySetInnerHTML: {
       __html: _dompurify.default.sanitize(value)
     }

package/ui/SnackbarModel.d.ts

@@ -6,8 +6,8 @@ declare function makeExtension(snackbarMessages: IObservableArray<any>): {
         readonly snackbarMessages: IObservableArray<any>;
     };
     actions: {
-        notify(message: string, level?: NotificationLevel | undefined, action?: SnackAction | undefined): void;
-        pushSnackbarMessage(message: string, level?: NotificationLevel | undefined, action?: SnackAction | undefined): number;
+        notify(message: string, level?: NotificationLevel, action?: SnackAction): void;
+        pushSnackbarMessage(message: string, level?: NotificationLevel, action?: SnackAction): number;
         popSnackbarMessage(): any;
         removeSnackbarMessage(message: string): void;
     };

package/util/declare.d.js

@@ -0,0 +1 @@
+"use strict";

package/util/offscreenCanvasPonyfill.d.ts

@@ -1 +1,8 @@
-export * from "./offscreenCanvas/ponyfill";
+declare type AbstractCanvas = any;
+declare type AbstractImageBitmap = any;
+export declare let createCanvas: (width: number, height: number) => AbstractCanvas;
+export declare let createImageBitmap: (canvas: AbstractCanvas) => Promise<AbstractImageBitmap>;
+/** the JS class (constructor) for offscreen-generated image bitmap data */
+export declare let ImageBitmapType: Function;
+export declare function drawImageOntoCanvasContext(imageData: any, context: CanvasRenderingContext2D): void;
+export {};

package/util/offscreenCanvasPonyfill.js

@@ -1,18 +1,146 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.createImageBitmap = exports.createCanvas = exports.ImageBitmapType = void 0;
+exports.drawImageOntoCanvasContext = drawImageOntoCanvasContext;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _detectNode = _interopRequireDefault(require("detect-node"));
+
+var _canvasSequencer = require("canvas-sequencer");
+
+// This file is a ponyfill for the HTML5 OffscreenCanvas API.
+var createCanvas;
+exports.createCanvas = createCanvas;
+var createImageBitmap;
+/** the JS class (constructor) for offscreen-generated image bitmap data */
+
+exports.createImageBitmap = createImageBitmap;
+var ImageBitmapType;
+exports.ImageBitmapType = ImageBitmapType;
+
+function drawImageOntoCanvasContext( // eslint-disable-next-line @typescript-eslint/no-explicit-any
+imageData, context) {
+  if (imageData.serializedCommands) {
+    var seq = new _canvasSequencer.CanvasSequence(imageData.serializedCommands);
+    seq.execute(context);
+  } else if (imageData instanceof ImageBitmapType) {
+    context.drawImage(imageData, 0, 0);
+  } else if (imageData.dataURL) {
+    throw new Error('dataURL deserialization no longer supported');
+  }
+}
+
+var weHave = {
+  realOffscreenCanvas: typeof OffscreenCanvas === 'function',
+  node: _detectNode.default
+};
+
+if (weHave.realOffscreenCanvas) {
+  exports.createCanvas = createCanvas = function createCanvas(width, height) {
+    return new OffscreenCanvas(width, height);
+  }; // eslint-disable-next-line no-restricted-globals
+
+
+  exports.createImageBitmap = createImageBitmap = window.createImageBitmap || self.createImageBitmap; // eslint-disable-next-line no-restricted-globals
+
+  exports.ImageBitmapType = ImageBitmapType = window.ImageBitmap || self.ImageBitmap;
+} else if (weHave.node) {
+  // use node-canvas if we are running in node (i.e. automated tests)
+  var _require = require('canvas'),
+      nodeCreateCanvas = _require.createCanvas,
+      Image = _require.Image;
+
+  exports.createCanvas = createCanvas = nodeCreateCanvas;
+
+  exports.createImageBitmap = createImageBitmap = /*#__PURE__*/function () {
+    var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(canvas) {
+      var dataUri,
+          img,
+          _args = arguments;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!(_args.length <= 1 ? 0 : _args.length - 1)) {
+                _context.next = 2;
+                break;
+              }
+
+              throw new Error('only one-argument uses of createImageBitmap are supported by the node offscreencanvas ponyfill');
+
+            case 2:
+              dataUri = canvas.toDataURL();
+              img = new Image();
+              return _context.abrupt("return", new Promise(function (resolve, reject) {
+                img.onload = function () {
+                  return resolve(img);
+                };
+
+                img.onerror = reject;
+                img.src = dataUri;
+              }));
+
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function createImageBitmap(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  exports.ImageBitmapType = ImageBitmapType = Image;
+} else {
+  exports.createCanvas = createCanvas = function createCanvas(width, height) {
+    var context = new _canvasSequencer.CanvasSequence();
+    return {
+      width: width,
+      height: height,
+      getContext: function getContext() {
+        return context;
+      }
+    };
+  };
+
+  exports.createImageBitmap = createImageBitmap = /*#__PURE__*/function () {
+    var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(canvas) {
+      var ctx;
+      return _regenerator.default.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              ctx = canvas.getContext('2d');
+              return _context2.abrupt("return", {
+                height: canvas.height,
+                width: canvas.width,
+                serializedCommands: ctx.toJSON(),
+                containsNoTransferables: true
+              });
+
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function createImageBitmap(_x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
 
-var _ponyfill = require("./offscreenCanvas/ponyfill");
-
-Object.keys(_ponyfill).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _ponyfill[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _ponyfill[key];
-    }
-  });
-});
+  exports.ImageBitmapType = ImageBitmapType = String;
+}

package/util/offscreenCanvasUtils.d.ts

@@ -1 +1,19 @@
-export * from './offscreenCanvas';
+/// <reference types="react" />
+export declare function renderToAbstractCanvas(width: number, height: number, opts: {
+    exportSVG?: {
+        rasterizeLayers?: boolean;
+    };
+    highResolutionScaling: number;
+}, cb: Function): Promise<{
+    canvasRecordedData: any;
+    reactElement?: undefined;
+    imageData?: undefined;
+} | {
+    reactElement: JSX.Element;
+    canvasRecordedData?: undefined;
+    imageData?: undefined;
+} | {
+    imageData: any;
+    canvasRecordedData?: undefined;
+    reactElement?: undefined;
+}>;

package/util/offscreenCanvasUtils.js

@@ -1,18 +1,152 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.renderToAbstractCanvas = renderToAbstractCanvas;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _offscreenCanvasPonyfill = require("./offscreenCanvasPonyfill");
+
+var _canvasSequencer = require("canvas-sequencer");
+
+var _index = require("./index");
+
+function renderToAbstractCanvas(_x, _x2, _x3, _x4) {
+  return _renderToAbstractCanvas.apply(this, arguments);
+}
+
+function _renderToAbstractCanvas() {
+  _renderToAbstractCanvas = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(width, height, opts, cb) {
+    var exportSVG, _opts$highResolutionS, highResolutionScaling, fakeCtx, scale, canvas, ctx, _canvas, _ctx;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            exportSVG = opts.exportSVG, _opts$highResolutionS = opts.highResolutionScaling, highResolutionScaling = _opts$highResolutionS === void 0 ? 1 : _opts$highResolutionS;
+
+            if (!exportSVG) {
+              _context.next = 37;
+              break;
+            }
+
+            if (exportSVG.rasterizeLayers) {
+              _context.next = 9;
+              break;
+            }
+
+            fakeCtx = new _canvasSequencer.CanvasSequence();
+            _context.next = 6;
+            return cb(fakeCtx);
+
+          case 6:
+            return _context.abrupt("return", {
+              canvasRecordedData: fakeCtx.toJSON()
+            });
+
+          case 9:
+            scale = 4;
+            canvas = (0, _offscreenCanvasPonyfill.createCanvas)(Math.ceil(width * scale), height * scale);
+            ctx = canvas.getContext('2d');
+
+            if (ctx) {
+              _context.next = 14;
+              break;
+            }
+
+            throw new Error('2d canvas rendering not supported on this platform');
+
+          case 14:
+            ctx.scale(scale, scale);
+            _context.next = 17;
+            return cb(ctx);
+
+          case 17:
+            _context.t0 = _react.default;
+            _context.t1 = width;
+            _context.t2 = height;
+
+            if (!('convertToBlob' in canvas)) {
+              _context.next = 30;
+              break;
+            }
+
+            _context.t4 = _index.blobToDataURL;
+            _context.next = 24;
+            return canvas.convertToBlob({
+              type: 'image/png'
+            });
+
+          case 24:
+            _context.t5 = _context.sent;
+            _context.next = 27;
+            return (0, _context.t4)(_context.t5);
+
+          case 27:
+            _context.t3 = _context.sent;
+            _context.next = 31;
+            break;
+
+          case 30:
+            _context.t3 = canvas.toDataURL();
+
+          case 31:
+            _context.t6 = _context.t3;
+            _context.t7 = {
+              width: _context.t1,
+              height: _context.t2,
+              xlinkHref: _context.t6
+            };
+            _context.t8 = _context.t0.createElement.call(_context.t0, "image", _context.t7);
+            return _context.abrupt("return", {
+              reactElement: _context.t8
+            });
+
+          case 35:
+            _context.next = 48;
+            break;
+
+          case 37:
+            _canvas = (0, _offscreenCanvasPonyfill.createCanvas)(Math.ceil(width * highResolutionScaling), height * highResolutionScaling);
+            _ctx = _canvas.getContext('2d');
+
+            if (_ctx) {
+              _context.next = 41;
+              break;
+            }
+
+            throw new Error('2d canvas rendering not supported on this platform');
+
+          case 41:
+            _ctx.scale(highResolutionScaling, highResolutionScaling);
+
+            _context.next = 44;
+            return cb(_ctx);
+
+          case 44:
+            _context.next = 46;
+            return (0, _offscreenCanvasPonyfill.createImageBitmap)(_canvas);
+
+          case 46:
+            _context.t9 = _context.sent;
+            return _context.abrupt("return", {
+              imageData: _context.t9
+            });
 
-var _offscreenCanvas = require("./offscreenCanvas");
-
-Object.keys(_offscreenCanvas).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _offscreenCanvas[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _offscreenCanvas[key];
-    }
-  });
-});
+          case 48:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _renderToAbstractCanvas.apply(this, arguments);
+}

package/util/types/mst.d.ts

@@ -77,13 +77,13 @@ export declare const FileLocation: import("mobx-state-tree").ISnapshotProcessor<
         internetAccountType: import("mobx-state-tree").ISimpleType<string>;
         authInfo: import("mobx-state-tree").IType<any, any, any>;
     }, {}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
-}>> | import("mobx-state-tree").ModelCreationType<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
-    locationType: import("mobx-state-tree").ISimpleType<"LocalPathLocation">;
-    localPath: import("mobx-state-tree").ISimpleType<string>;
 }>> | import("mobx-state-tree").ModelCreationType<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
     locationType: import("mobx-state-tree").ISimpleType<"BlobLocation">;
     name: import("mobx-state-tree").ISimpleType<string>;
     blobId: import("mobx-state-tree").ISimpleType<string>;
+}>> | import("mobx-state-tree").ModelCreationType<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
+    locationType: import("mobx-state-tree").ISimpleType<"LocalPathLocation">;
+    localPath: import("mobx-state-tree").ISimpleType<string>;
 }>>, {
     locationType: "UriLocation";
     uri: string;
@@ -93,12 +93,12 @@ export declare const FileLocation: import("mobx-state-tree").ISnapshotProcessor<
         authInfo: import("mobx-state-tree").IType<any, any, any>;
     }> | undefined;
 } | import("mobx-state-tree").ModelSnapshotType<{
-    locationType: import("mobx-state-tree").ISimpleType<"LocalPathLocation">;
-    localPath: import("mobx-state-tree").ISimpleType<string>;
-}> | import("mobx-state-tree").ModelSnapshotType<{
     locationType: import("mobx-state-tree").ISimpleType<"BlobLocation">;
     name: import("mobx-state-tree").ISimpleType<string>;
     blobId: import("mobx-state-tree").ISimpleType<string>;
+}> | import("mobx-state-tree").ModelSnapshotType<{
+    locationType: import("mobx-state-tree").ISimpleType<"LocalPathLocation">;
+    localPath: import("mobx-state-tree").ISimpleType<string>;
 }>, import("mobx-state-tree").ModelCreationType<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
     locationType: import("mobx-state-tree").ISimpleType<"UriLocation">;
     uri: import("mobx-state-tree").ISimpleType<string>;
@@ -109,10 +109,10 @@ export declare const FileLocation: import("mobx-state-tree").ISnapshotProcessor<
         authInfo: import("mobx-state-tree").IType<any, any, any>;
     }, {}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
 }>> | import("mobx-state-tree").ModelInstanceTypeProps<{
-    locationType: import("mobx-state-tree").ISimpleType<"LocalPathLocation">;
-    localPath: import("mobx-state-tree").ISimpleType<string>;
-}> | import("mobx-state-tree").ModelInstanceTypeProps<{
     locationType: import("mobx-state-tree").ISimpleType<"BlobLocation">;
     name: import("mobx-state-tree").ISimpleType<string>;
     blobId: import("mobx-state-tree").ISimpleType<string>;
+}> | import("mobx-state-tree").ModelInstanceTypeProps<{
+    locationType: import("mobx-state-tree").ISimpleType<"LocalPathLocation">;
+    localPath: import("mobx-state-tree").ISimpleType<string>;
 }>>, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;

package/util/offscreenCanvas/Canvas2DContextShim/Canvas2DContextShim.test.js

@@ -1,15 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _ = _interopRequireDefault(require("."));
-
-test('serialize a single command and read back out', function () {
-  var ctx = new _.default(100, 100);
-  ctx.arc(20, 21, 22, 23, 24);
-  var cmds = Array.from(ctx.getCommands());
-  expect(cmds).toEqual([{
-    name: 'arc',
-    args: [20, 21, 22, 23, 24]
-  }]);
-});

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

@@ -1,56 +0,0 @@
-/// <reference types="react" />
-/// <reference types="offscreencanvas" />
-import { Command } from './types';
-/** get the params type of real method in OffscreenCanvasRenderingContext2D */
-declare type RealP<METHODNAME extends keyof OffscreenCanvasRenderingContext2D> = OffscreenCanvasRenderingContext2D[METHODNAME] extends (...arg0: any[]) => any ? Parameters<OffscreenCanvasRenderingContext2D[METHODNAME]> : never;
-/** get the return type of real method in OffscreenCanvasRenderingContext2D */
-declare type RealRet<METHODNAME extends keyof OffscreenCanvasRenderingContext2D> = OffscreenCanvasRenderingContext2D[METHODNAME] extends (...arg0: any[]) => any ? ReturnType<OffscreenCanvasRenderingContext2D[METHODNAME]> : never;
-/** get the type of the params of a method of the canvas shim */
-export declare type ShimP<METHODNAME extends keyof OffscreenCanvasRenderingContext2DShim> = OffscreenCanvasRenderingContext2DShim[METHODNAME] extends (...arg0: any[]) => any ? Parameters<OffscreenCanvasRenderingContext2DShim[METHODNAME]> : never;
-/** decode all the commands in the given buffer and replay them onto the given context */
-export declare function replayCommandsOntoContext(targetContext: CanvasRenderingContext2D, encodedCommands: Iterable<Command>): void;
-export default class OffscreenCanvasRenderingContext2DShim {
-    width: number;
-    height: number;
-    currentFont: string;
-    currentStrokeStyle: string;
-    currentFillStyle: string;
-    recordedCommands: Command[];
-    constructor(width: number, height: number);
-    private pushMethodCall;
-    private pushSetterCall;
-    getSerializedCommands(): Command[];
-    getSerializedSvg(): JSX.Element;
-    getCommands(): Command[];
-    set strokeStyle(style: string);
-    set fillStyle(style: string);
-    set font(style: string);
-    arc(...args: RealP<'arc'>): RealRet<'arc'>;
-    arcTo(...args: RealP<'arcTo'>): RealRet<'arcTo'>;
-    beginPath(...args: RealP<'beginPath'>): RealRet<'beginPath'>;
-    clearRect(...args: RealP<'clearRect'>): RealRet<'clearRect'>;
-    closePath(...args: RealP<'closePath'>): RealRet<'closePath'>;
-    ellipse(...args: RealP<'ellipse'>): RealRet<'ellipse'>;
-    fill(...args: RealP<'fill'>): RealRet<'fill'>;
-    fillRect(...args: RealP<'fillRect'>): RealRet<'fillRect'>;
-    fillText(...args: RealP<'fillText'>): RealRet<'fillText'>;
-    lineTo(...args: RealP<'lineTo'>): RealRet<'lineTo'>;
-    measureText(...args: RealP<'measureText'>): {
-        width: number;
-        height: number;
-    };
-    moveTo(...args: RealP<'moveTo'>): RealRet<'moveTo'>;
-    quadraticCurveTo(...args: RealP<'quadraticCurveTo'>): RealRet<'quadraticCurveTo'>;
-    rect(...args: RealP<'rect'>): RealRet<'rect'>;
-    restore(...args: RealP<'restore'>): RealRet<'restore'>;
-    rotate(...args: RealP<'rotate'>): RealRet<'rotate'>;
-    save(...args: RealP<'save'>): RealRet<'save'>;
-    setTransform(...args: RealP<'setTransform'>): RealRet<'setTransform'>;
-    scale(...args: RealP<'scale'>): RealRet<'scale'>;
-    stroke(): RealRet<'stroke'>;
-    strokeRect(...args: RealP<'strokeRect'>): RealRet<'strokeRect'>;
-    strokeText(...args: RealP<'strokeText'>): RealRet<'strokeText'>;
-    transform(...args: RealP<'transform'>): RealRet<'transform'>;
-    translate(...args: RealP<'translate'>): RealRet<'translate'>;
-}
-export {};