js-draw 0.18.1 → 0.18.2

package/dist/mjs/src/components/ImageComponent.d.ts

@@ -0,0 +1,31 @@
+import LineSegment2 from '../math/LineSegment2';
+import Mat33, { Mat33Array } from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import AbstractRenderer, { RenderableImage } from '../rendering/renderers/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+export default class ImageComponent extends AbstractComponent {
+    protected contentBBox: Rect2;
+    private image;
+    constructor(image: RenderableImage);
+    private getImageRect;
+    private recomputeBBox;
+    static fromImage(elem: HTMLImageElement, transform: Mat33): Promise<ImageComponent>;
+    render(canvas: AbstractRenderer, _visibleRect?: Rect2): void;
+    getProportionalRenderingTime(): number;
+    intersects(lineSegment: LineSegment2): boolean;
+    protected serializeToJSON(): {
+        src: string;
+        label: string | undefined;
+        width: number;
+        height: number;
+        transform: Mat33Array;
+    };
+    protected applyTransformation(affineTransfm: Mat33): void;
+    description(localizationTable: ImageComponentLocalization): string;
+    getAltText(): string | undefined;
+    getURL(): string;
+    getTransformation(): Mat33;
+    protected createClone(): AbstractComponent;
+    static deserializeFromJSON(data: any): ImageComponent;
+}

package/dist/mjs/src/components/ImageComponent.mjs

@@ -0,0 +1,146 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import  Mat33  from '../math/Mat33.mjs';
+import  Rect2  from '../math/Rect2.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
+// Represents a raster image.
+export default class ImageComponent extends AbstractComponent {
+    constructor(image) {
+        var _a, _b, _c;
+        super('image-component');
+        this.image = Object.assign(Object.assign({}, image), { label: (_c = (_b = (_a = image.label) !== null && _a !== void 0 ? _a : image.image.getAttribute('alt')) !== null && _b !== void 0 ? _b : image.image.getAttribute('aria-label')) !== null && _c !== void 0 ? _c : undefined });
+        const isHTMLImageElem = (elem) => {
+            return elem.getAttribute('src') !== undefined;
+        };
+        if (isHTMLImageElem(image.image) && !image.image.complete) {
+            image.image.onload = () => this.recomputeBBox();
+        }
+        this.recomputeBBox();
+    }
+    getImageRect() {
+        return new Rect2(0, 0, this.image.image.width, this.image.image.height);
+    }
+    recomputeBBox() {
+        this.contentBBox = this.getImageRect();
+        this.contentBBox = this.contentBBox.transformedBoundingBox(this.image.transform);
+    }
+    // Load from an image. Waits for the image to load if incomplete.
+    static fromImage(elem, transform) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!elem.complete) {
+                yield new Promise((resolve, reject) => {
+                    elem.onload = resolve;
+                    elem.onerror = reject;
+                    elem.onabort = reject;
+                });
+            }
+            let width, height;
+            if (typeof elem.width === 'number' && typeof elem.height === 'number'
+                && elem.width !== 0 && elem.height !== 0) {
+                width = elem.width;
+                height = elem.height;
+            }
+            else {
+                width = elem.clientWidth;
+                height = elem.clientHeight;
+            }
+            let image;
+            let url = (_a = elem.src) !== null && _a !== void 0 ? _a : '';
+            if (!url.startsWith('data:image/')) {
+                // Convert to a data URL:
+                const canvas = document.createElement('canvas');
+                canvas.width = width;
+                canvas.height = height;
+                const ctx = canvas.getContext('2d');
+                ctx.drawImage(elem, 0, 0, canvas.width, canvas.height);
+                url = canvas.toDataURL();
+                image = canvas;
+            }
+            else {
+                image = new Image();
+                image.src = url;
+                image.width = width;
+                image.height = height;
+            }
+            image.setAttribute('alt', (_b = elem.getAttribute('alt')) !== null && _b !== void 0 ? _b : '');
+            image.setAttribute('aria-label', (_c = elem.getAttribute('aria-label')) !== null && _c !== void 0 ? _c : '');
+            return new ImageComponent({
+                image,
+                base64Url: url,
+                transform: transform,
+            });
+        });
+    }
+    render(canvas, _visibleRect) {
+        canvas.startObject(this.contentBBox);
+        canvas.drawImage(this.image);
+        canvas.endObject(this.getLoadSaveData());
+    }
+    getProportionalRenderingTime() {
+        // Estimate: Equivalent to a stroke with 10 segments.
+        return 10;
+    }
+    intersects(lineSegment) {
+        const rect = this.getImageRect();
+        const edges = rect.getEdges().map(edge => edge.transformedBy(this.image.transform));
+        for (const edge of edges) {
+            if (edge.intersects(lineSegment)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    serializeToJSON() {
+        return {
+            src: this.image.base64Url,
+            label: this.image.label,
+            // Store the width and height for bounding box computations while the image is loading.
+            width: this.image.image.width,
+            height: this.image.image.height,
+            transform: this.image.transform.toArray(),
+        };
+    }
+    applyTransformation(affineTransfm) {
+        this.image.transform = affineTransfm.rightMul(this.image.transform);
+        this.recomputeBBox();
+    }
+    description(localizationTable) {
+        return this.image.label ? localizationTable.imageNode(this.image.label) : localizationTable.unlabeledImageNode;
+    }
+    getAltText() {
+        return this.image.label;
+    }
+    getURL() {
+        return this.image.base64Url;
+    }
+    getTransformation() {
+        return this.image.transform;
+    }
+    createClone() {
+        return new ImageComponent(Object.assign({}, this.image));
+    }
+    static deserializeFromJSON(data) {
+        if (!(typeof data.src === 'string')) {
+            throw new Error(`${data} has invalid format! Expected src property.`);
+        }
+        const image = new Image();
+        image.src = data.src;
+        image.width = data.width;
+        image.height = data.height;
+        return new ImageComponent({
+            image: image,
+            base64Url: image.src,
+            label: data.label,
+            transform: new Mat33(...data.transform),
+        });
+    }
+}
+AbstractComponent.registerComponent('image-component', ImageComponent.deserializeFromJSON);

package/dist/mjs/src/components/RestylableComponent.d.ts

@@ -0,0 +1,24 @@
+import Color4 from '../Color4';
+import SerializableCommand from '../commands/SerializableCommand';
+import Editor from '../Editor';
+import TextStyle from '../rendering/TextRenderingStyle';
+import AbstractComponent from './AbstractComponent';
+export interface ComponentStyle {
+    color?: Color4;
+    textStyle?: TextStyle;
+}
+export declare const createRestyleComponentCommand: (initialStyle: ComponentStyle, newStyle: ComponentStyle, component: RestyleableComponent) => SerializableCommand;
+export declare const isRestylableComponent: (component: AbstractComponent) => component is RestyleableComponent;
+export interface RestyleableComponent extends AbstractComponent {
+    getStyle(): ComponentStyle;
+    updateStyle(style: ComponentStyle): SerializableCommand;
+    /**
+     * Set the style of this component in a way that can't be undone/redone
+     * (does not create a command).
+     *
+     * Prefer `updateStyle(style).apply(editor)`.
+     */
+    forceStyle(style: ComponentStyle, editor: Editor | null): void;
+    isRestylableComponent: true;
+}
+export default RestyleableComponent;

package/dist/mjs/src/components/RestylableComponent.mjs

@@ -0,0 +1,80 @@
+import  Color4  from '../Color4.mjs';
+import  SerializableCommand  from '../commands/SerializableCommand.mjs';
+import  UnresolvedSerializableCommand  from '../commands/UnresolvedCommand.mjs';
+import  { textStyleFromJSON, textStyleToJSON }  from '../rendering/TextRenderingStyle.mjs';
+const serializeComponentStyle = (style) => {
+    const result = {};
+    if (style.color) {
+        result.color = style.color.toHexString();
+    }
+    if (style.textStyle) {
+        result.textStyle = textStyleToJSON(style.textStyle);
+    }
+    return result;
+};
+const deserializeComponentStyle = (json) => {
+    const color = json.color ? Color4.fromHex(json.color) : undefined;
+    const textStyle = json.textStyle ? textStyleFromJSON(json.textStyle) : undefined;
+    return {
+        color,
+        textStyle,
+    };
+};
+// For internal use by Components implementing `updateStyle`:
+export const createRestyleComponentCommand = (initialStyle, newStyle, component) => {
+    return new DefaultRestyleComponentCommand(initialStyle, newStyle, component.getId(), component);
+};
+// Returns true if `component` is a `RestylableComponent`.
+export const isRestylableComponent = (component) => {
+    const hasMethods = 'getStyle' in component && 'updateStyle' in component && 'forceStyle' in component;
+    if (!hasMethods) {
+        return false;
+    }
+    if (!('isRestylableComponent' in component) || !component['isRestylableComponent']) {
+        return false;
+    }
+    return true;
+};
+const defaultRestyleComponentCommandId = 'default-restyle-element';
+class DefaultRestyleComponentCommand extends UnresolvedSerializableCommand {
+    constructor(originalStyle, newStyle, componentID, component) {
+        super(defaultRestyleComponentCommandId, componentID, component);
+        this.originalStyle = originalStyle;
+        this.newStyle = newStyle;
+    }
+    getComponent(editor) {
+        this.resolveComponent(editor.image);
+        const component = this.component;
+        if (!component || !component['forceStyle'] || !component['updateStyle']) {
+            throw new Error('this.component is missing forceStyle and/or updateStyle methods!');
+        }
+        return component;
+    }
+    apply(editor) {
+        this.getComponent(editor).forceStyle(this.newStyle, editor);
+    }
+    unapply(editor) {
+        this.getComponent(editor).forceStyle(this.originalStyle, editor);
+    }
+    description(editor, localizationTable) {
+        return localizationTable.restyledElement(this.getComponent(editor).description(localizationTable));
+    }
+    serializeToJSON() {
+        return {
+            id: this.componentID,
+            originalStyle: serializeComponentStyle(this.originalStyle),
+            newStyle: serializeComponentStyle(this.newStyle),
+        };
+    }
+}
+(() => {
+    SerializableCommand.register(defaultRestyleComponentCommandId, (json, _editor) => {
+        const origStyle = deserializeComponentStyle(json.originalStyle);
+        const newStyle = deserializeComponentStyle(json.newStyle);
+        const id = json.id;
+        if (typeof json.id !== 'string') {
+            throw new Error(`json.id is of type ${(typeof json.id)}, not string.`);
+        }
+        return new DefaultRestyleComponentCommand(origStyle, newStyle, id);
+    });
+})();

package/dist/mjs/src/components/SVGGlobalAttributesObject.d.ts

@@ -0,0 +1,21 @@
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+type GlobalAttrsList = Array<[string, string | null]>;
+export default class SVGGlobalAttributesObject extends AbstractComponent {
+    private readonly attrs;
+    protected contentBBox: Rect2;
+    constructor(attrs: GlobalAttrsList);
+    render(canvas: AbstractRenderer, _visibleRect?: Rect2): void;
+    intersects(_lineSegment: LineSegment2): boolean;
+    protected applyTransformation(_affineTransfm: Mat33): void;
+    isSelectable(): boolean;
+    protected createClone(): SVGGlobalAttributesObject;
+    description(localization: ImageComponentLocalization): string;
+    protected serializeToJSON(): string | null;
+    static deserializeFromString(data: string): AbstractComponent;
+}
+export {};

package/dist/mjs/src/components/SVGGlobalAttributesObject.mjs

@@ -0,0 +1,59 @@
+//
+// Used by `SVGLoader`s to store unrecognised global attributes
+// (e.g. unrecognised XML namespace declarations).
+// @internal
+// @packageDocumentation
+//
+import  Rect2  from '../math/Rect2.mjs';
+import  SVGRenderer  from '../rendering/renderers/SVGRenderer.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
+const componentKind = 'svg-global-attributes';
+// Stores global SVG attributes (e.g. namespace identifiers.)
+export default class SVGGlobalAttributesObject extends AbstractComponent {
+    constructor(attrs) {
+        super(componentKind);
+        this.attrs = attrs;
+        this.contentBBox = Rect2.empty;
+    }
+    render(canvas, _visibleRect) {
+        if (!(canvas instanceof SVGRenderer)) {
+            // Don't draw unrenderable objects if we can't
+            return;
+        }
+        for (const [attr, value] of this.attrs) {
+            canvas.setRootSVGAttribute(attr, value);
+        }
+    }
+    intersects(_lineSegment) {
+        return false;
+    }
+    applyTransformation(_affineTransfm) {
+    }
+    isSelectable() {
+        return false;
+    }
+    createClone() {
+        return new SVGGlobalAttributesObject(this.attrs);
+    }
+    description(localization) {
+        return localization.svgObject;
+    }
+    serializeToJSON() {
+        return JSON.stringify(this.attrs);
+    }
+    static deserializeFromString(data) {
+        const json = JSON.parse(data);
+        const attrs = [];
+        const numericAndSpaceContentExp = /^[ \t\n0-9.-eE]+$/;
+        // Don't deserialize all attributes, just those that should be safe.
+        for (const [key, val] of json) {
+            if (key === 'viewBox' || key === 'width' || key === 'height') {
+                if (val && numericAndSpaceContentExp.exec(val)) {
+                    attrs.push([key, val]);
+                }
+            }
+        }
+        return new SVGGlobalAttributesObject(attrs);
+    }
+}
+AbstractComponent.registerComponent(componentKind, SVGGlobalAttributesObject.deserializeFromString);

package/dist/mjs/src/components/Stroke.d.ts

@@ -0,0 +1,40 @@
+import SerializableCommand from '../commands/SerializableCommand';
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Path from '../math/Path';
+import Rect2 from '../math/Rect2';
+import Editor from '../Editor';
+import AbstractRenderer, { RenderablePathSpec } from '../rendering/renderers/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+import RestyleableComponent, { ComponentStyle } from './RestylableComponent';
+export default class Stroke extends AbstractComponent implements RestyleableComponent {
+    private parts;
+    protected contentBBox: Rect2;
+    readonly isRestylableComponent: true;
+    private approximateRenderingTime;
+    constructor(parts: RenderablePathSpec[]);
+    getStyle(): ComponentStyle;
+    updateStyle(style: ComponentStyle): SerializableCommand;
+    forceStyle(style: ComponentStyle, editor: Editor | null): void;
+    intersects(line: LineSegment2): boolean;
+    render(canvas: AbstractRenderer, visibleRect?: Rect2): void;
+    getProportionalRenderingTime(): number;
+    private bboxForPart;
+    protected applyTransformation(affineTransfm: Mat33): void;
+    getPath(): Path;
+    description(localization: ImageComponentLocalization): string;
+    protected createClone(): AbstractComponent;
+    protected serializeToJSON(): {
+        style: {
+            fill: string;
+            stroke: {
+                color: string;
+                width: number;
+            } | undefined;
+        };
+        path: string;
+    }[];
+    /** @internal */
+    static deserializeFromJSON(json: any): Stroke;
+}

package/dist/mjs/src/components/Stroke.mjs

@@ -0,0 +1,185 @@
+import  Path  from '../math/Path.mjs';
+import  Rect2  from '../math/Rect2.mjs';
+import  { styleFromJSON, styleToJSON }  from '../rendering/RenderingStyle.mjs';
+import  AbstractComponent  from './AbstractComponent.mjs';
+import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
+export default class Stroke extends AbstractComponent {
+    // Creates a `Stroke` from the given `parts`. All parts should have the
+    // same color.
+    constructor(parts) {
+        var _a;
+        super('stroke');
+        // eslint-disable-next-line @typescript-eslint/prefer-as-const
+        this.isRestylableComponent = true;
+        this.approximateRenderingTime = 0;
+        this.parts = [];
+        for (const section of parts) {
+            const path = Path.fromRenderable(section);
+            const pathBBox = this.bboxForPart(path.bbox, section.style);
+            if (!this.contentBBox) {
+                this.contentBBox = pathBBox;
+            }
+            else {
+                this.contentBBox = this.contentBBox.union(pathBBox);
+            }
+            this.parts.push({
+                path,
+                // To implement RenderablePathSpec
+                startPoint: path.startPoint,
+                style: section.style,
+                commands: path.parts,
+            });
+            this.approximateRenderingTime += path.parts.length;
+        }
+        (_a = this.contentBBox) !== null && _a !== void 0 ? _a : (this.contentBBox = Rect2.empty);
+    }
+    getStyle() {
+        if (this.parts.length === 0) {
+            return {};
+        }
+        const firstPart = this.parts[0];
+        if (firstPart.style.stroke === undefined
+            || firstPart.style.stroke.width === 0) {
+            return {
+                color: firstPart.style.fill,
+            };
+        }
+        return {
+            color: firstPart.style.stroke.color,
+        };
+    }
+    updateStyle(style) {
+        return createRestyleComponentCommand(this.getStyle(), style, this);
+    }
+    forceStyle(style, editor) {
+        if (!style.color) {
+            return;
+        }
+        this.parts = this.parts.map((part) => {
+            const newStyle = Object.assign(Object.assign({}, part.style), { stroke: part.style.stroke ? Object.assign({}, part.style.stroke) : undefined });
+            // Change the stroke color if a stroked shape. Else,
+            // change the fill.
+            if (newStyle.stroke && newStyle.stroke.width > 0) {
+                newStyle.stroke.color = style.color;
+            }
+            else {
+                newStyle.fill = style.color;
+            }
+            return {
+                path: part.path,
+                startPoint: part.startPoint,
+                commands: part.commands,
+                style: newStyle,
+            };
+        });
+        if (editor) {
+            editor.image.queueRerenderOf(this);
+            editor.queueRerender();
+        }
+    }
+    intersects(line) {
+        for (const part of this.parts) {
+            if (part.path.intersection(line).length > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    render(canvas, visibleRect) {
+        var _a, _b;
+        canvas.startObject(this.getBBox());
+        for (const part of this.parts) {
+            const bbox = this.bboxForPart(part.path.bbox, part.style);
+            if (visibleRect) {
+                if (!bbox.intersects(visibleRect)) {
+                    continue;
+                }
+                const muchBiggerThanVisible = bbox.size.x > visibleRect.size.x * 2 || bbox.size.y > visibleRect.size.y * 2;
+                if (muchBiggerThanVisible && !part.path.roughlyIntersects(visibleRect, (_b = (_a = part.style.stroke) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 0)) {
+                    continue;
+                }
+            }
+            canvas.drawPath(part);
+        }
+        canvas.endObject(this.getLoadSaveData());
+    }
+    getProportionalRenderingTime() {
+        return this.approximateRenderingTime;
+    }
+    // Grows the bounding box for a given stroke part based on that part's style.
+    bboxForPart(origBBox, style) {
+        if (!style.stroke) {
+            return origBBox;
+        }
+        return origBBox.grownBy(style.stroke.width / 2);
+    }
+    applyTransformation(affineTransfm) {
+        this.contentBBox = Rect2.empty;
+        let isFirstPart = true;
+        // Update each part
+        this.parts = this.parts.map((part) => {
+            const newPath = part.path.transformedBy(affineTransfm);
+            const newStyle = Object.assign(Object.assign({}, part.style), { stroke: part.style.stroke ? Object.assign({}, part.style.stroke) : undefined });
+            // Approximate the scale factor.
+            if (newStyle.stroke) {
+                const scaleFactor = affineTransfm.getScaleFactor();
+                newStyle.stroke.width *= scaleFactor;
+            }
+            const newBBox = this.bboxForPart(newPath.bbox, newStyle);
+            if (isFirstPart) {
+                this.contentBBox = newBBox;
+                isFirstPart = false;
+            }
+            else {
+                this.contentBBox = this.contentBBox.union(newBBox);
+            }
+            return {
+                path: newPath,
+                startPoint: newPath.startPoint,
+                commands: newPath.parts,
+                style: newStyle,
+            };
+        });
+    }
+    getPath() {
+        let result = null;
+        for (const part of this.parts) {
+            if (result) {
+                result = result.union(part.path);
+            }
+            else {
+                result !== null && result !== void 0 ? result : (result = part.path);
+            }
+        }
+        return result !== null && result !== void 0 ? result : Path.empty;
+    }
+    description(localization) {
+        return localization.stroke;
+    }
+    createClone() {
+        return new Stroke(this.parts);
+    }
+    serializeToJSON() {
+        return this.parts.map(part => {
+            return {
+                style: styleToJSON(part.style),
+                path: part.path.serialize(),
+            };
+        });
+    }
+    /** @internal */
+    static deserializeFromJSON(json) {
+        if (typeof json === 'string') {
+            json = JSON.parse(json);
+        }
+        if (typeof json !== 'object' || typeof json.length !== 'number') {
+            throw new Error(`${json} is missing required field, parts, or parts is of the wrong type.`);
+        }
+        const pathSpec = json.map((part) => {
+            const style = styleFromJSON(part.style);
+            return Path.fromString(part.path).toRenderable(style);
+        });
+        return new Stroke(pathSpec);
+    }
+}
+AbstractComponent.registerComponent('stroke', Stroke.deserializeFromJSON);

package/dist/mjs/src/components/TextComponent.d.ts

@@ -0,0 +1,53 @@
+import SerializableCommand from '../commands/SerializableCommand';
+import LineSegment2 from '../math/LineSegment2';
+import Mat33 from '../math/Mat33';
+import Rect2 from '../math/Rect2';
+import Editor from '../Editor';
+import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
+import { TextStyle } from '../rendering/TextRenderingStyle';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+import RestyleableComponent, { ComponentStyle } from './RestylableComponent';
+export default class TextComponent extends AbstractComponent implements RestyleableComponent {
+    protected readonly textObjects: Array<string | TextComponent>;
+    private transform;
+    private style;
+    protected contentBBox: Rect2;
+    readonly isRestylableComponent: true;
+    constructor(textObjects: Array<string | TextComponent>, transform: Mat33, style: TextStyle);
+    static applyTextStyles(ctx: CanvasRenderingContext2D, style: TextStyle): void;
+    private static textMeasuringCtx;
+    private static estimateTextDimens;
+    private static getTextDimens;
+    private computeBBoxOfPart;
+    private recomputeBBox;
+    private renderInternal;
+    render(canvas: AbstractRenderer, _visibleRect?: Rect2): void;
+    getProportionalRenderingTime(): number;
+    intersects(lineSegment: LineSegment2): boolean;
+    getStyle(): ComponentStyle;
+    updateStyle(style: ComponentStyle): SerializableCommand;
+    forceStyle(style: ComponentStyle, editor: Editor | null): void;
+    getTextStyle(): {
+        renderingStyle: {
+            fill: import("../Color4").default;
+            stroke: {
+                color: import("../Color4").default;
+                width: number;
+            } | undefined;
+        };
+        size: number;
+        fontFamily: string;
+        fontWeight?: string | undefined;
+        fontVariant?: string | undefined;
+    };
+    getBaselinePos(): import("../lib").Vec3;
+    getTransform(): Mat33;
+    protected applyTransformation(affineTransfm: Mat33): void;
+    protected createClone(): AbstractComponent;
+    getText(): string;
+    description(localizationTable: ImageComponentLocalization): string;
+    protected serializeToJSON(): Record<string, any>;
+    static deserializeFromString(json: any): TextComponent;
+    static fromLines(lines: string[], transform: Mat33, style: TextStyle): AbstractComponent;
+}