js-draw 0.23.1 → 0.24.1

package/dist/mjs/src/components/BackgroundComponent.mjs

@@ -1,286 +0,0 @@
-import  Color4  from '../Color4.mjs';
-import  { EditorImageEventType }  from '../EditorImage.mjs';
-import  Rect2  from '../math/Rect2.mjs';
-import  AbstractComponent  from './AbstractComponent.mjs';
-import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
-import  Path, { PathCommandType }  from '../math/Path.mjs';
-import  { Vec2 }  from '../math/Vec2.mjs';
-import  Viewport  from '../Viewport.mjs';
-import  { toRoundedString }  from '../math/rounding.mjs';
-export var BackgroundType;
-(function (BackgroundType) {
-    BackgroundType[BackgroundType["SolidColor"] = 0] = "SolidColor";
-    BackgroundType[BackgroundType["Grid"] = 1] = "Grid";
-    BackgroundType[BackgroundType["None"] = 2] = "None";
-})(BackgroundType || (BackgroundType = {}));
-export const imageBackgroundCSSClassName = 'js-draw-image-background';
-// Class name prefix indicating the size of the background's grid cells (if present).
-export const imageBackgroundGridSizeCSSPrefix = 'js-draw-image-background-grid-';
-// Flag included in rendered SVGs (etc) that indicates that the secondary color of the
-// background has been manually set.
-export const imageBackgroundNonAutomaticSecondaryColorCSSClassName = 'js-draw-image-background-non-automatic-secondary-color';
-export const backgroundTypeToClassNameMap = {
-    [BackgroundType.Grid]: 'js-draw-image-background-grid',
-    [BackgroundType.SolidColor]: imageBackgroundCSSClassName,
-    [BackgroundType.None]: '',
-};
-// Represents the background of the editor's canvas.
-export default class BackgroundComponent extends AbstractComponent {
-    constructor(backgroundType, mainColor) {
-        super('image-background', 0);
-        this.backgroundType = backgroundType;
-        this.mainColor = mainColor;
-        this.viewportSizeChangeListener = null;
-        this.gridSize = Viewport.getGridSize(2);
-        this.gridStrokeWidth = 0.7;
-        this.secondaryColor = null;
-        // eslint-disable-next-line @typescript-eslint/prefer-as-const
-        this.isRestylableComponent = true;
-        this.contentBBox = Rect2.empty;
-    }
-    static ofGrid(backgroundColor, gridSize, gridColor, gridStrokeWidth) {
-        const background = new BackgroundComponent(BackgroundType.Grid, backgroundColor);
-        if (gridSize !== undefined) {
-            background.gridSize = gridSize;
-        }
-        if (gridColor !== undefined) {
-            background.secondaryColor = gridColor;
-        }
-        if (gridStrokeWidth !== undefined) {
-            background.gridStrokeWidth = gridStrokeWidth;
-        }
-        return background;
-    }
-    getBackgroundType() {
-        return this.backgroundType;
-    }
-    // @internal
-    getMainColor() {
-        return this.mainColor;
-    }
-    // @internal
-    getSecondaryColor() {
-        return this.secondaryColor;
-    }
-    // @internal
-    getGridSize() {
-        return this.gridSize;
-    }
-    getStyle() {
-        let color = this.mainColor;
-        if (this.backgroundType === BackgroundType.None) {
-            color = undefined;
-        }
-        return {
-            color,
-        };
-    }
-    updateStyle(style) {
-        return createRestyleComponentCommand(this.getStyle(), style, this);
-    }
-    // @internal
-    forceStyle(style, editor) {
-        const fill = style.color;
-        if (!fill) {
-            return;
-        }
-        this.mainColor = fill;
-        // A solid background and transparent fill is equivalent to no background.
-        if (fill.eq(Color4.transparent) && this.backgroundType === BackgroundType.SolidColor) {
-            this.backgroundType = BackgroundType.None;
-        }
-        else if (this.backgroundType === BackgroundType.None) {
-            this.backgroundType = BackgroundType.SolidColor;
-        }
-        if (editor) {
-            editor.image.queueRerenderOf(this);
-            editor.queueRerender();
-        }
-    }
-    onAddToImage(image) {
-        if (this.viewportSizeChangeListener) {
-            console.warn('onAddToImage called when background is already in an image');
-            this.onRemoveFromImage();
-        }
-        this.viewportSizeChangeListener = image.notifier.on(EditorImageEventType.ExportViewportChanged, () => {
-            this.recomputeBBox(image);
-        });
-        this.recomputeBBox(image);
-    }
-    onRemoveFromImage() {
-        var _a;
-        (_a = this.viewportSizeChangeListener) === null || _a === void 0 ? void 0 : _a.remove();
-        this.viewportSizeChangeListener = null;
-    }
-    recomputeBBox(image) {
-        const importExportRect = image.getImportExportViewport().visibleRect;
-        if (!this.contentBBox.eq(importExportRect)) {
-            this.contentBBox = importExportRect;
-            // Re-render this if already added to the EditorImage.
-            image.queueRerenderOf(this);
-        }
-    }
-    generateGridPath(visibleRect) {
-        var _a, _b;
-        const targetRect = (_b = (_a = visibleRect === null || visibleRect === void 0 ? void 0 : visibleRect.grownBy(this.gridStrokeWidth)) === null || _a === void 0 ? void 0 : _a.intersection(this.contentBBox)) !== null && _b !== void 0 ? _b : this.contentBBox;
-        const roundDownToGrid = (coord) => Math.floor(coord / this.gridSize) * this.gridSize;
-        const roundUpToGrid = (coord) => Math.ceil(coord / this.gridSize) * this.gridSize;
-        const startY = roundUpToGrid(targetRect.y);
-        const endY = roundDownToGrid(targetRect.y + targetRect.h);
-        const startX = roundUpToGrid(targetRect.x);
-        const endX = roundDownToGrid(targetRect.x + targetRect.w);
-        const result = [];
-        // Don't generate grids with a huge number of rows/columns -- such grids
-        // take a long time to render and are likely invisible due to the number of
-        // cells.
-        const rowCount = (endY - startY) / this.gridSize;
-        const colCount = (endX - startX) / this.gridSize;
-        const maxGridCols = 1000;
-        const maxGridRows = 1000;
-        if (rowCount > maxGridRows || colCount > maxGridCols) {
-            return Path.empty;
-        }
-        const startPoint = Vec2.of(targetRect.x, startY);
-        for (let y = startY; y <= endY; y += this.gridSize) {
-            result.push({
-                kind: PathCommandType.MoveTo,
-                point: Vec2.of(targetRect.x, y),
-            });
-            result.push({
-                kind: PathCommandType.LineTo,
-                point: Vec2.of(targetRect.x + targetRect.w, y),
-            });
-        }
-        for (let x = startX; x <= endX; x += this.gridSize) {
-            result.push({
-                kind: PathCommandType.MoveTo,
-                point: Vec2.of(x, targetRect.y),
-            });
-            result.push({
-                kind: PathCommandType.LineTo,
-                point: Vec2.of(x, targetRect.y + targetRect.h)
-            });
-        }
-        return new Path(startPoint, result);
-    }
-    render(canvas, visibleRect) {
-        if (this.backgroundType === BackgroundType.None) {
-            return;
-        }
-        const clip = this.backgroundType === BackgroundType.Grid;
-        canvas.startObject(this.contentBBox, clip);
-        if (this.backgroundType === BackgroundType.SolidColor || this.backgroundType === BackgroundType.Grid) {
-            // If the rectangle for this region contains the visible rect,
-            // we can fill the entire visible rectangle (which may be more efficient than
-            // filling the entire region for this.)
-            if (visibleRect) {
-                const intersection = visibleRect.intersection(this.contentBBox);
-                if (intersection) {
-                    canvas.fillRect(intersection, this.mainColor);
-                }
-            }
-            else {
-                canvas.fillRect(this.contentBBox, this.mainColor);
-            }
-        }
-        if (this.backgroundType === BackgroundType.Grid) {
-            let gridColor = this.secondaryColor;
-            gridColor !== null && gridColor !== void 0 ? gridColor : (gridColor = Color4.ofRGBA(1 - this.mainColor.r, 1 - this.mainColor.g, 1 - this.mainColor.b, 0.2));
-            // If the background fill is completely transparent, ensure visibility on otherwise light
-            // and dark backgrounds.
-            if (this.mainColor.a === 0) {
-                gridColor = Color4.ofRGBA(0.5, 0.5, 0.5, 0.2);
-            }
-            const style = {
-                fill: Color4.transparent,
-                stroke: { width: this.gridStrokeWidth, color: gridColor }
-            };
-            canvas.drawPath(this.generateGridPath(visibleRect).toRenderable(style));
-        }
-        const backgroundTypeCSSClass = backgroundTypeToClassNameMap[this.backgroundType];
-        const classNames = [imageBackgroundCSSClassName];
-        if (backgroundTypeCSSClass !== imageBackgroundCSSClassName) {
-            classNames.push(backgroundTypeCSSClass);
-            const gridSizeStr = toRoundedString(this.gridSize).replace(/[.]/g, 'p');
-            classNames.push(imageBackgroundGridSizeCSSPrefix + gridSizeStr);
-        }
-        if (this.secondaryColor !== null) {
-            classNames.push(imageBackgroundNonAutomaticSecondaryColorCSSClassName);
-        }
-        canvas.endObject(this.getLoadSaveData(), classNames);
-    }
-    intersects(lineSegment) {
-        return this.contentBBox.getEdges().some(edge => edge.intersects(lineSegment));
-    }
-    isSelectable() {
-        return false;
-    }
-    isBackground() {
-        return true;
-    }
-    serializeToJSON() {
-        var _a;
-        return {
-            mainColor: this.mainColor.toHexString(),
-            secondaryColor: (_a = this.secondaryColor) === null || _a === void 0 ? void 0 : _a.toHexString(),
-            backgroundType: this.backgroundType,
-            gridSize: this.gridSize,
-            gridStrokeWidth: this.gridStrokeWidth,
-        };
-    }
-    applyTransformation(_affineTransfm) {
-        // Do nothing — it doesn't make sense to transform the background.
-    }
-    description(localizationTable) {
-        if (this.backgroundType === BackgroundType.SolidColor) {
-            return localizationTable.filledBackgroundWithColor(this.mainColor.toString());
-        }
-        else if (this.backgroundType === BackgroundType.None) {
-            return localizationTable.emptyBackground;
-        }
-        else if (this.backgroundType === BackgroundType.Grid) {
-            return localizationTable.gridBackground;
-        }
-        else {
-            const exhaustivenessCheck = this.backgroundType;
-            return exhaustivenessCheck;
-        }
-    }
-    createClone() {
-        return new BackgroundComponent(this.backgroundType, this.mainColor);
-    }
-    // @internal
-    static deserializeFromJSON(json) {
-        var _a, _b;
-        if (typeof json === 'string') {
-            json = JSON.parse(json);
-        }
-        if (typeof json.mainColor !== 'string') {
-            throw new Error('Error deserializing — mainColor must be of type string.');
-        }
-        let backgroundType;
-        const jsonBackgroundType = json.backgroundType;
-        if (jsonBackgroundType === BackgroundType.None || jsonBackgroundType === BackgroundType.Grid
-            || jsonBackgroundType === BackgroundType.SolidColor) {
-            backgroundType = jsonBackgroundType;
-        }
-        else {
-            const exhaustivenessCheck = jsonBackgroundType;
-            return exhaustivenessCheck;
-        }
-        const mainColor = Color4.fromHex(json.mainColor);
-        const secondaryColor = json.secondaryColor ? Color4.fromHex(json.secondaryColor) : null;
-        const gridSize = (_a = json.gridSize) !== null && _a !== void 0 ? _a : undefined;
-        const gridStrokeWidth = (_b = json.gridStrokeWidth) !== null && _b !== void 0 ? _b : undefined;
-        const result = new BackgroundComponent(backgroundType, mainColor);
-        result.secondaryColor = secondaryColor;
-        if (gridSize) {
-            result.gridSize = gridSize;
-        }
-        if (gridStrokeWidth) {
-            result.gridStrokeWidth = gridStrokeWidth;
-        }
-        return result;
-    }
-}
-AbstractComponent.registerComponent('image-background', BackgroundComponent.deserializeFromJSON);

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

@@ -1,31 +0,0 @@
-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 applyTransformation(affineTransfm: Mat33): void;
-    description(localizationTable: ImageComponentLocalization): string;
-    getAltText(): string | undefined;
-    getURL(): string;
-    getTransformation(): Mat33;
-    protected createClone(): AbstractComponent;
-    protected serializeToJSON(): {
-        src: string;
-        label: string | undefined;
-        width: number;
-        height: number;
-        transform: Mat33Array;
-    };
-    static deserializeFromJSON(data: any): ImageComponent;
-}

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

@@ -1,151 +0,0 @@
-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  { assertIsNumber, assertIsNumberArray }  from '../util/assertions.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;
-    }
-    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));
-    }
-    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(),
-        };
-    }
-    static deserializeFromJSON(data) {
-        if (!(typeof data.src === 'string')) {
-            throw new Error(`${data} has invalid format! Expected src property.`);
-        }
-        assertIsNumberArray(data.transform);
-        assertIsNumber(data.width);
-        assertIsNumber(data.height);
-        const image = new Image();
-        image.src = data.src;
-        image.width = data.width;
-        image.height = data.height;
-        const transform = new Mat33(...data.transform);
-        return new ImageComponent({
-            image: image,
-            base64Url: data.src,
-            label: data.label,
-            transform,
-        });
-    }
-}
-AbstractComponent.registerComponent('image-component', ImageComponent.deserializeFromJSON);

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

@@ -1,80 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,59 +0,0 @@
-//
-// 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);