js-draw 0.23.1 → 0.24.1

package/dist/mjs/rendering/renderers/SVGRenderer.d.ts

@@ -0,0 +1,57 @@
+import { LoadSaveDataTable } from '../../components/AbstractComponent';
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/shapes/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Viewport from '../../Viewport';
+import RenderingStyle from '../RenderingStyle';
+import TextRenderingStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage, RenderablePathSpec } from './AbstractRenderer';
+export declare const renderedStylesheetId = "js-draw-style-sheet";
+/**
+ * Renders onto an `SVGElement`.
+ *
+ * @see {@link Editor.toSVG}
+ */
+export default class SVGRenderer extends AbstractRenderer {
+    private elem;
+    private sanitize;
+    private lastPathStyle;
+    private lastPathString;
+    private objectElems;
+    private overwrittenAttrs;
+    /**
+     * Creates a renderer that renders onto `elem`. If `sanitize`, don't render potentially untrusted data.
+     *
+     * `viewport` is used to determine the translation/rotation/scaling/output size of the rendered
+     * data.
+     */
+    constructor(elem: SVGSVGElement, viewport: Viewport, sanitize?: boolean);
+    private addStyleSheet;
+    setRootSVGAttribute(name: string, value: string | null): void;
+    displaySize(): Vec2;
+    clear(): void;
+    private addPathToSVG;
+    drawPath(pathSpec: RenderablePathSpec): void;
+    private transformFrom;
+    private textContainer;
+    private textContainerTransform;
+    private textParentStyle;
+    drawText(text: string, transform: Mat33, style: TextRenderingStyle): void;
+    drawImage(image: RenderableImage): void;
+    startObject(boundingBox: Rect2): void;
+    endObject(loaderData?: LoadSaveDataTable, elemClassNames?: string[]): void;
+    private unimplementedMessage;
+    protected beginPath(_startPoint: Point2): void;
+    protected endPath(_style: RenderingStyle): void;
+    protected lineTo(_point: Point2): void;
+    protected moveTo(_point: Point2): void;
+    protected traceCubicBezierCurve(_controlPoint1: Point2, _controlPoint2: Point2, _endPoint: Point2): void;
+    protected traceQuadraticBezierCurve(_controlPoint: Point2, _endPoint: Point2): void;
+    drawPoints(...points: Point2[]): void;
+    drawSVGElem(elem: SVGElement): void;
+    isTooSmallToRender(_rect: Rect2): boolean;
+    static fromViewport(viewport: Viewport, sanitize?: boolean): {
+        element: SVGSVGElement;
+        renderer: SVGRenderer;
+    };
+}

package/dist/mjs/rendering/renderers/SVGRenderer.mjs

@@ -0,0 +1,352 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import  Mat33  from '../../math/Mat33.mjs';
+import  Path  from '../../math/shapes/Path.mjs';
+import  { toRoundedString }  from '../../math/rounding.mjs';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  { svgAttributesDataKey, svgStyleAttributesDataKey }  from '../../SVGLoader.mjs';
+import  { stylesEqual }  from '../RenderingStyle.mjs';
+import  AbstractRenderer  from './AbstractRenderer.mjs';
+export var renderedStylesheetId = 'js-draw-style-sheet';
+var svgNameSpace = 'http://www.w3.org/2000/svg';
+var defaultTextStyle = {
+    fontWeight: '400',
+    fontStyle: 'normal',
+};
+/**
+ * Renders onto an `SVGElement`.
+ *
+ * @see {@link Editor.toSVG}
+ */
+var SVGRenderer = /** @class */ (function (_super) {
+    __extends(SVGRenderer, _super);
+    /**
+     * Creates a renderer that renders onto `elem`. If `sanitize`, don't render potentially untrusted data.
+     *
+     * `viewport` is used to determine the translation/rotation/scaling/output size of the rendered
+     * data.
+     */
+    function SVGRenderer(elem, viewport, sanitize) {
+        if (sanitize === void 0) { sanitize = false; }
+        var _this = _super.call(this, viewport) || this;
+        _this.elem = elem;
+        _this.sanitize = sanitize;
+        _this.lastPathStyle = null;
+        _this.lastPathString = [];
+        _this.objectElems = null;
+        _this.overwrittenAttrs = {};
+        _this.textContainer = null;
+        _this.textContainerTransform = null;
+        _this.textParentStyle = defaultTextStyle;
+        _this.clear();
+        _this.addStyleSheet();
+        return _this;
+    }
+    SVGRenderer.prototype.addStyleSheet = function () {
+        if (!this.elem.querySelector("#".concat(renderedStylesheetId))) {
+            // Default to rounded strokes.
+            var styleSheet = document.createElementNS('http://www.w3.org/2000/svg', 'style');
+            styleSheet.innerHTML = "\n\t\t\t\tpath {\n\t\t\t\t\tstroke-linecap: round;\n\t\t\t\t\tstroke-linejoin: round;\n\t\t\t\t}\n\n\t\t\t\ttext {\n\t\t\t\t\twhite-space: pre;\n\t\t\t\t}\n\t\t\t".replace(/\s+/g, '');
+            styleSheet.setAttribute('id', renderedStylesheetId);
+            this.elem.appendChild(styleSheet);
+        }
+    };
+    // Sets an attribute on the root SVG element.
+    SVGRenderer.prototype.setRootSVGAttribute = function (name, value) {
+        if (this.sanitize) {
+            return;
+        }
+        // Make the original value of the attribute restorable on clear
+        if (!(name in this.overwrittenAttrs)) {
+            this.overwrittenAttrs[name] = this.elem.getAttribute(name);
+        }
+        if (value !== null) {
+            this.elem.setAttribute(name, value);
+        }
+        else {
+            this.elem.removeAttribute(name);
+        }
+    };
+    SVGRenderer.prototype.displaySize = function () {
+        return Vec2.of(this.elem.clientWidth, this.elem.clientHeight);
+    };
+    SVGRenderer.prototype.clear = function () {
+        this.lastPathString = [];
+        if (!this.sanitize) {
+            // Restore all all attributes
+            for (var attrName in this.overwrittenAttrs) {
+                var value = this.overwrittenAttrs[attrName];
+                if (value) {
+                    this.elem.setAttribute(attrName, value);
+                }
+                else {
+                    this.elem.removeAttribute(attrName);
+                }
+            }
+            this.overwrittenAttrs = {};
+        }
+    };
+    // Push [this.fullPath] to the SVG
+    SVGRenderer.prototype.addPathToSVG = function () {
+        var _a;
+        if (!this.lastPathStyle || this.lastPathString.length === 0) {
+            return;
+        }
+        var pathElem = document.createElementNS(svgNameSpace, 'path');
+        pathElem.setAttribute('d', this.lastPathString.join(' '));
+        var style = this.lastPathStyle;
+        if (style.fill.a > 0) {
+            pathElem.setAttribute('fill', style.fill.toHexString());
+        }
+        else {
+            pathElem.setAttribute('fill', 'none');
+        }
+        if (style.stroke) {
+            pathElem.setAttribute('stroke', style.stroke.color.toHexString());
+            pathElem.setAttribute('stroke-width', toRoundedString(style.stroke.width));
+        }
+        this.elem.appendChild(pathElem);
+        (_a = this.objectElems) === null || _a === void 0 ? void 0 : _a.push(pathElem);
+    };
+    SVGRenderer.prototype.drawPath = function (pathSpec) {
+        var style = pathSpec.style;
+        var path = Path.fromRenderable(pathSpec).transformedBy(this.getCanvasToScreenTransform());
+        // Try to extend the previous path, if possible
+        if (this.lastPathString.length === 0 || !this.lastPathStyle || !stylesEqual(this.lastPathStyle, style)) {
+            this.addPathToSVG();
+            this.lastPathStyle = style;
+            this.lastPathString = [];
+        }
+        this.lastPathString.push(path.toString());
+    };
+    // Apply [elemTransform] to [elem]. Uses both a `matrix` and `.x`, `.y` properties if `setXY` is true.
+    // Otherwise, just uses a `matrix`.
+    SVGRenderer.prototype.transformFrom = function (elemTransform, elem, inCanvasSpace, setXY) {
+        if (inCanvasSpace === void 0) { inCanvasSpace = false; }
+        if (setXY === void 0) { setXY = true; }
+        var transform = !inCanvasSpace ? this.getCanvasToScreenTransform().rightMul(elemTransform) : elemTransform;
+        var translation = transform.transformVec2(Vec2.zero);
+        if (setXY) {
+            transform = transform.rightMul(Mat33.translation(translation.times(-1)));
+        }
+        if (!transform.eq(Mat33.identity)) {
+            elem.style.transform = "matrix(\n\t\t\t\t".concat(transform.a1, ", ").concat(transform.b1, ",\n\t\t\t\t").concat(transform.a2, ", ").concat(transform.b2, ",\n\t\t\t\t").concat(transform.a3, ", ").concat(transform.b3, "\n\t\t\t)");
+        }
+        else {
+            elem.style.transform = '';
+        }
+        if (setXY) {
+            elem.setAttribute('x', "".concat(toRoundedString(translation.x)));
+            elem.setAttribute('y', "".concat(toRoundedString(translation.y)));
+        }
+    };
+    SVGRenderer.prototype.drawText = function (text, transform, style) {
+        var _this = this;
+        var _a;
+        var applyTextStyles = function (elem, style) {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            if (style.fontFamily !== ((_a = _this.textParentStyle) === null || _a === void 0 ? void 0 : _a.fontFamily)) {
+                elem.style.fontFamily = style.fontFamily;
+            }
+            if (style.fontVariant !== ((_b = _this.textParentStyle) === null || _b === void 0 ? void 0 : _b.fontVariant)) {
+                elem.style.fontVariant = (_c = style.fontVariant) !== null && _c !== void 0 ? _c : '';
+            }
+            if (style.fontWeight !== ((_d = _this.textParentStyle) === null || _d === void 0 ? void 0 : _d.fontWeight)) {
+                elem.style.fontWeight = (_e = style.fontWeight) !== null && _e !== void 0 ? _e : '';
+            }
+            if (style.fontStyle !== ((_f = _this.textParentStyle) === null || _f === void 0 ? void 0 : _f.fontStyle)) {
+                elem.style.fontStyle = (_g = style.fontStyle) !== null && _g !== void 0 ? _g : '';
+            }
+            if (style.size !== ((_h = _this.textParentStyle) === null || _h === void 0 ? void 0 : _h.size)) {
+                elem.style.fontSize = style.size + 'px';
+            }
+            var fillString = style.renderingStyle.fill.toHexString();
+            // TODO: Uncomment at some future major version release --- currently causes incompatibility due
+            //       to an SVG parsing bug in older versions.
+            //const parentFillString = this.textParentStyle?.renderingStyle?.fill?.toHexString();
+            //if (fillString !== parentFillString) {
+            elem.style.fill = fillString;
+            //}
+            if (style.renderingStyle.stroke) {
+                var strokeStyle = style.renderingStyle.stroke;
+                elem.style.stroke = strokeStyle.color.toHexString();
+                elem.style.strokeWidth = strokeStyle.width + 'px';
+            }
+        };
+        transform = this.getCanvasToScreenTransform().rightMul(transform);
+        if (!this.textContainer) {
+            var container = document.createElementNS(svgNameSpace, 'text');
+            container.appendChild(document.createTextNode(text));
+            // Don't set .x/.y properties (just use .style.transform).
+            // Child nodes aren't translated by .x/.y properties, but are by .style.transform.
+            var setXY = false;
+            this.transformFrom(transform, container, true, setXY);
+            applyTextStyles(container, style);
+            this.elem.appendChild(container);
+            (_a = this.objectElems) === null || _a === void 0 ? void 0 : _a.push(container);
+            if (this.objectLevel > 0) {
+                this.textContainer = container;
+                this.textContainerTransform = transform;
+                this.textParentStyle = __assign(__assign({}, defaultTextStyle), style);
+            }
+        }
+        else {
+            var elem = document.createElementNS(svgNameSpace, 'tspan');
+            elem.appendChild(document.createTextNode(text));
+            this.textContainer.appendChild(elem);
+            // Make .x/.y relative to the parent.
+            transform = this.textContainerTransform.inverse().rightMul(transform);
+            // .style.transform does nothing to tspan elements. As such, we need to set x/y:
+            var translation = transform.transformVec2(Vec2.zero);
+            elem.setAttribute('x', "".concat(toRoundedString(translation.x)));
+            elem.setAttribute('y', "".concat(toRoundedString(translation.y)));
+            applyTextStyles(elem, style);
+        }
+    };
+    SVGRenderer.prototype.drawImage = function (image) {
+        var _a, _b, _c, _d, _e, _f;
+        var label = (_b = (_a = image.label) !== null && _a !== void 0 ? _a : image.image.getAttribute('aria-label')) !== null && _b !== void 0 ? _b : '';
+        if (label === '') {
+            label = (_c = image.image.getAttribute('alt')) !== null && _c !== void 0 ? _c : '';
+        }
+        var svgImgElem = document.createElementNS(svgNameSpace, 'image');
+        svgImgElem.setAttribute('href', image.base64Url);
+        svgImgElem.setAttribute('width', (_d = image.image.getAttribute('width')) !== null && _d !== void 0 ? _d : '');
+        svgImgElem.setAttribute('height', (_e = image.image.getAttribute('height')) !== null && _e !== void 0 ? _e : '');
+        svgImgElem.setAttribute('aria-label', label);
+        this.transformFrom(image.transform, svgImgElem);
+        this.elem.appendChild(svgImgElem);
+        (_f = this.objectElems) === null || _f === void 0 ? void 0 : _f.push(svgImgElem);
+    };
+    SVGRenderer.prototype.startObject = function (boundingBox) {
+        _super.prototype.startObject.call(this, boundingBox);
+        // Only accumulate a path within an object
+        this.lastPathString = [];
+        this.lastPathStyle = null;
+        this.textContainer = null;
+        this.textParentStyle = defaultTextStyle;
+        this.objectElems = [];
+    };
+    SVGRenderer.prototype.endObject = function (loaderData, elemClassNames) {
+        var _a, _b;
+        var _c;
+        _super.prototype.endObject.call(this, loaderData);
+        // Don't extend paths across objects
+        this.addPathToSVG();
+        if (loaderData && !this.sanitize) {
+            // Restore any attributes unsupported by the app.
+            for (var _i = 0, _d = (_c = this.objectElems) !== null && _c !== void 0 ? _c : []; _i < _d.length; _i++) {
+                var elem = _d[_i];
+                var attrs = loaderData[svgAttributesDataKey];
+                var styleAttrs = loaderData[svgStyleAttributesDataKey];
+                if (attrs) {
+                    for (var _e = 0, attrs_1 = attrs; _e < attrs_1.length; _e++) {
+                        var _f = attrs_1[_e], attr = _f[0], value = _f[1];
+                        elem.setAttribute(attr, value);
+                    }
+                }
+                if (styleAttrs) {
+                    for (var _g = 0, styleAttrs_1 = styleAttrs; _g < styleAttrs_1.length; _g++) {
+                        var attr = styleAttrs_1[_g];
+                        elem.style.setProperty(attr.key, attr.value, attr.priority);
+                    }
+                }
+            }
+        }
+        // Add class names to the object, if given.
+        if (elemClassNames && this.objectElems) {
+            if (this.objectElems.length === 1) {
+                (_a = this.objectElems[0].classList).add.apply(_a, elemClassNames);
+            }
+            else {
+                var wrapper = document.createElementNS(svgNameSpace, 'g');
+                (_b = wrapper.classList).add.apply(_b, elemClassNames);
+                for (var _h = 0, _j = this.objectElems; _h < _j.length; _h++) {
+                    var elem = _j[_h];
+                    elem.remove();
+                    wrapper.appendChild(elem);
+                }
+                this.elem.appendChild(wrapper);
+            }
+        }
+    };
+    // Not implemented -- use drawPath instead.
+    SVGRenderer.prototype.unimplementedMessage = function () { throw new Error('Not implemenented!'); };
+    SVGRenderer.prototype.beginPath = function (_startPoint) { this.unimplementedMessage(); };
+    SVGRenderer.prototype.endPath = function (_style) { this.unimplementedMessage(); };
+    SVGRenderer.prototype.lineTo = function (_point) { this.unimplementedMessage(); };
+    SVGRenderer.prototype.moveTo = function (_point) { this.unimplementedMessage(); };
+    SVGRenderer.prototype.traceCubicBezierCurve = function (_controlPoint1, _controlPoint2, _endPoint) { this.unimplementedMessage(); };
+    SVGRenderer.prototype.traceQuadraticBezierCurve = function (_controlPoint, _endPoint) { this.unimplementedMessage(); };
+    SVGRenderer.prototype.drawPoints = function () {
+        var _this = this;
+        var points = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            points[_i] = arguments[_i];
+        }
+        points.map(function (point) {
+            var elem = document.createElementNS(svgNameSpace, 'circle');
+            elem.setAttribute('cx', "".concat(point.x));
+            elem.setAttribute('cy', "".concat(point.y));
+            elem.setAttribute('r', '15');
+            _this.elem.appendChild(elem);
+        });
+    };
+    // Renders a **copy** of the given element.
+    SVGRenderer.prototype.drawSVGElem = function (elem) {
+        if (this.sanitize) {
+            return;
+        }
+        // Don't add multiple copies of the default stylesheet.
+        if (elem.tagName.toLowerCase() === 'style' && elem.getAttribute('id') === renderedStylesheetId) {
+            return;
+        }
+        this.elem.appendChild(elem.cloneNode(true));
+    };
+    SVGRenderer.prototype.isTooSmallToRender = function (_rect) {
+        return false;
+    };
+    // Creates a new SVG element and SVGRenerer with attributes set for the given Viewport.
+    SVGRenderer.fromViewport = function (viewport, sanitize) {
+        if (sanitize === void 0) { sanitize = true; }
+        var svgNameSpace = 'http://www.w3.org/2000/svg';
+        var result = document.createElementNS(svgNameSpace, 'svg');
+        var rect = viewport.getScreenRectSize();
+        // rect.x -> size of rect in x direction, rect.y -> size of rect in y direction.
+        result.setAttribute('viewBox', [0, 0, rect.x, rect.y].map(function (part) { return toRoundedString(part); }).join(' '));
+        result.setAttribute('width', toRoundedString(rect.x));
+        result.setAttribute('height', toRoundedString(rect.y));
+        // Ensure the image can be identified as an SVG if downloaded.
+        // See https://jwatt.org/svg/authoring/
+        result.setAttribute('version', '1.1');
+        result.setAttribute('baseProfile', 'full');
+        result.setAttribute('xmlns', svgNameSpace);
+        return { element: result, renderer: new SVGRenderer(result, viewport, sanitize) };
+    };
+    return SVGRenderer;
+}(AbstractRenderer));
+export default SVGRenderer;

package/dist/mjs/rendering/renderers/TextOnlyRenderer.d.ts

@@ -0,0 +1,29 @@
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/shapes/Rect2';
+import Vec3 from '../../math/Vec3';
+import Viewport from '../../Viewport';
+import { TextRendererLocalization } from '../localization';
+import RenderingStyle from '../RenderingStyle';
+import TextRenderingStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage } from './AbstractRenderer';
+export default class TextOnlyRenderer extends AbstractRenderer {
+    private localizationTable;
+    private descriptionBuilder;
+    private pathCount;
+    private textNodeCount;
+    private imageNodeCount;
+    constructor(viewport: Viewport, localizationTable: TextRendererLocalization);
+    displaySize(): Vec3;
+    clear(): void;
+    getDescription(): string;
+    protected beginPath(_startPoint: Vec3): void;
+    protected endPath(_style: RenderingStyle): void;
+    protected lineTo(_point: Vec3): void;
+    protected moveTo(_point: Vec3): void;
+    protected traceCubicBezierCurve(_p1: Vec3, _p2: Vec3, _p3: Vec3): void;
+    protected traceQuadraticBezierCurve(_controlPoint: Vec3, _endPoint: Vec3): void;
+    drawText(text: string, _transform: Mat33, _style: TextRenderingStyle): void;
+    drawImage(image: RenderableImage): void;
+    isTooSmallToRender(rect: Rect2): boolean;
+    drawPoints(..._points: Vec3[]): void;
+}

package/dist/mjs/rendering/renderers/TextOnlyRenderer.mjs

@@ -0,0 +1,87 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  AbstractRenderer  from './AbstractRenderer.mjs';
+// Outputs a description of what was rendered.
+var TextOnlyRenderer = /** @class */ (function (_super) {
+    __extends(TextOnlyRenderer, _super);
+    function TextOnlyRenderer(viewport, localizationTable) {
+        var _this = _super.call(this, viewport) || this;
+        _this.localizationTable = localizationTable;
+        _this.descriptionBuilder = [];
+        _this.pathCount = 0;
+        _this.textNodeCount = 0;
+        _this.imageNodeCount = 0;
+        return _this;
+    }
+    TextOnlyRenderer.prototype.displaySize = function () {
+        // We don't have a graphical display, export a reasonable size.
+        return Vec2.of(500, 500);
+    };
+    TextOnlyRenderer.prototype.clear = function () {
+        this.descriptionBuilder = [];
+        this.pathCount = 0;
+        this.textNodeCount = 0;
+        this.imageNodeCount = 0;
+    };
+    TextOnlyRenderer.prototype.getDescription = function () {
+        return __spreadArray(__spreadArray(__spreadArray([
+            this.localizationTable.pathNodeCount(this.pathCount)
+        ], (this.textNodeCount > 0 ? [this.localizationTable.textNodeCount(this.textNodeCount)] : []), true), (this.imageNodeCount > 0 ? [this.localizationTable.imageNodeCount(this.imageNodeCount)] : []), true), this.descriptionBuilder, true).join('\n');
+    };
+    TextOnlyRenderer.prototype.beginPath = function (_startPoint) {
+    };
+    TextOnlyRenderer.prototype.endPath = function (_style) {
+        this.pathCount++;
+    };
+    TextOnlyRenderer.prototype.lineTo = function (_point) {
+    };
+    TextOnlyRenderer.prototype.moveTo = function (_point) {
+    };
+    TextOnlyRenderer.prototype.traceCubicBezierCurve = function (_p1, _p2, _p3) {
+    };
+    TextOnlyRenderer.prototype.traceQuadraticBezierCurve = function (_controlPoint, _endPoint) {
+    };
+    TextOnlyRenderer.prototype.drawText = function (text, _transform, _style) {
+        this.descriptionBuilder.push(this.localizationTable.textNode(text));
+        this.textNodeCount++;
+    };
+    TextOnlyRenderer.prototype.drawImage = function (image) {
+        var label = image.label ? this.localizationTable.imageNode(image.label) : this.localizationTable.unlabeledImageNode;
+        this.descriptionBuilder.push(label);
+        this.imageNodeCount++;
+    };
+    TextOnlyRenderer.prototype.isTooSmallToRender = function (rect) {
+        return rect.maxDimension < 15 / this.getSizeOfCanvasPixelOnScreen();
+    };
+    TextOnlyRenderer.prototype.drawPoints = function () {
+        var _points = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            _points[_i] = arguments[_i];
+        }
+    };
+    return TextOnlyRenderer;
+}(AbstractRenderer));
+export default TextOnlyRenderer;

package/dist/mjs/rendering/renderers/TextOnlyRenderer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/shortcuts/KeyBinding.d.ts

@@ -0,0 +1,46 @@
+export interface KeyCombination {
+    /** A key (e.g. `a`, `b`, `control`). */
+    readonly key: string;
+    /**
+     * Whether the shift key must be pressed to trigger the shortcut.
+     */
+    readonly shiftKey: boolean | undefined;
+    /** Whether the control key must be pressed to trigger the shortcut */
+    readonly ctrlKey: boolean;
+    /** Whether the alt key must be pressed to trigger the shortcut */
+    readonly altKey: boolean;
+    /** Whether the meta key must be pressed to trigger the shortcut */
+    readonly metaKey: boolean;
+    /** True if this shortcut/key combination applies for either control or meta. */
+    readonly controlOrMeta: boolean;
+}
+/** Represents a key combination that can trigger a keyboard shortcut. */
+export default class KeyBinding implements KeyCombination {
+    /** @inheritdoc */
+    readonly key: string;
+    /**
+     * If undefined, the state of the shift key is ignored.
+     */
+    readonly shiftKey: boolean | undefined;
+    /** @inheritdoc */
+    readonly ctrlKey: boolean;
+    /** @inheritdoc */
+    readonly altKey: boolean;
+    /** @inheritdoc */
+    readonly metaKey: boolean;
+    /** @inheritdoc */
+    readonly controlOrMeta: boolean;
+    constructor(trigger: KeyCombination);
+    /** Returns true if and only if `keyEvent` should trigger this shortcut. */
+    matchesEvent(keyEvent: Partial<KeyCombination>): boolean;
+    /**
+     * Returns a string representation of this shortcut in the same format accepted by
+     * {@link fromString}.
+     */
+    toString(): string;
+    /**
+     * Accepts a string in the form `modifier1+modifier2+...+key` (e.g. `Ctrl+Shift+a`)
+     * and returns the corresponding `KeyboardShortcut`.
+     */
+    static fromString(shortcutStr: string): KeyBinding;
+}