js-draw 0.25.1 → 1.0.1

package/dist/cjs/commands/Command.js

@@ -1,61 +1,34 @@
 "use strict";
-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 __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
-var Command = exports.Command = /** @class */ (function () {
-    function Command() {
-    }
+class Command {
     // Called when the command is being deleted
-    Command.prototype.onDrop = function (_editor) { };
-    Command.union = function (a, b) {
-        return new /** @class */ (function (_super) {
-            __extends(class_1, _super);
-            function class_1() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            class_1.prototype.apply = function (editor) {
+    onDrop(_editor) { }
+    static union(a, b) {
+        return new class extends Command {
+            apply(editor) {
                 a.apply(editor);
                 b.apply(editor);
-            };
-            class_1.prototype.unapply = function (editor) {
+            }
+            unapply(editor) {
                 b.unapply(editor);
                 a.unapply(editor);
-            };
-            class_1.prototype.description = function (editor, localizationTable) {
-                var aDescription = a.description(editor, localizationTable);
-                var bDescription = b.description(editor, localizationTable);
+            }
+            description(editor, localizationTable) {
+                const aDescription = a.description(editor, localizationTable);
+                const bDescription = b.description(editor, localizationTable);
                 if (aDescription === bDescription) {
                     return aDescription;
                 }
-                return "".concat(aDescription, ", ").concat(bDescription);
-            };
-            return class_1;
-        }(Command));
-    };
-    Command.empty = new /** @class */ (function (_super) {
-        __extends(class_2, _super);
-        function class_2() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        class_2.prototype.description = function (_editor, _localizationTable) { return ''; };
-        class_2.prototype.apply = function (_editor) { };
-        class_2.prototype.unapply = function (_editor) { };
-        return class_2;
-    }(Command));
-    return Command;
-}());
+                return `${aDescription}, ${bDescription}`;
+            }
+        };
+    }
+}
+exports.Command = Command;
+Command.empty = new class extends Command {
+    description(_editor, _localizationTable) { return ''; }
+    apply(_editor) { }
+    unapply(_editor) { }
+};
 exports.default = Command;

package/dist/cjs/commands/Duplicate.js

@@ -1,23 +1,11 @@
 "use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var describeComponentList_1 = require("../components/util/describeComponentList");
-var Erase_1 = require("./Erase");
-var SerializableCommand_1 = require("./SerializableCommand");
+const describeComponentList_1 = __importDefault(require("../components/util/describeComponentList"));
+const Erase_1 = __importDefault(require("./Erase"));
+const SerializableCommand_1 = __importDefault(require("./SerializableCommand"));
 /**
  * A command that duplicates the {@link AbstractComponent}s it's given. This command
  * is the reverse of an {@link Erase} command.
@@ -41,39 +29,35 @@ var SerializableCommand_1 = require("./SerializableCommand");
  *
  * @see {@link Editor.dispatch} {@link EditorImage.getElementsIntersectingRegion}
  */
-var Duplicate = /** @class */ (function (_super) {
-    __extends(Duplicate, _super);
-    function Duplicate(toDuplicate) {
-        var _this = _super.call(this, 'duplicate') || this;
-        _this.toDuplicate = toDuplicate;
-        _this.duplicates = toDuplicate.map(function (elem) { return elem.clone(); });
-        _this.reverse = new Erase_1.default(_this.duplicates);
-        return _this;
+class Duplicate extends SerializableCommand_1.default {
+    constructor(toDuplicate) {
+        super('duplicate');
+        this.toDuplicate = toDuplicate;
+        this.duplicates = toDuplicate.map(elem => elem.clone());
+        this.reverse = new Erase_1.default(this.duplicates);
     }
-    Duplicate.prototype.apply = function (editor) {
+    apply(editor) {
         this.reverse.unapply(editor);
-    };
-    Duplicate.prototype.unapply = function (editor) {
+    }
+    unapply(editor) {
         this.reverse.apply(editor);
-    };
-    Duplicate.prototype.onDrop = function (editor) {
+    }
+    onDrop(editor) {
         this.reverse.onDrop(editor);
-    };
-    Duplicate.prototype.description = function (_editor, localizationTable) {
-        var _a;
+    }
+    description(_editor, localizationTable) {
         if (this.duplicates.length === 0) {
             return localizationTable.duplicatedNoElements;
         }
-        return localizationTable.duplicateAction((_a = (0, describeComponentList_1.default)(localizationTable, this.duplicates)) !== null && _a !== void 0 ? _a : localizationTable.elements, this.duplicates.length);
-    };
-    Duplicate.prototype.serializeToJSON = function () {
-        return this.toDuplicate.map(function (elem) { return elem.getId(); });
-    };
-    return Duplicate;
-}(SerializableCommand_1.default));
-(function () {
-    SerializableCommand_1.default.register('duplicate', function (json, editor) {
-        var elems = json.map(function (id) { return editor.image.lookupElement(id); });
+        return localizationTable.duplicateAction((0, describeComponentList_1.default)(localizationTable, this.duplicates) ?? localizationTable.elements, this.duplicates.length);
+    }
+    serializeToJSON() {
+        return this.toDuplicate.map(elem => elem.getId());
+    }
+}
+(() => {
+    SerializableCommand_1.default.register('duplicate', (json, editor) => {
+        const elems = json.map((id) => editor.image.lookupElement(id));
         return new Duplicate(elems);
     });
 })();

package/dist/cjs/commands/Erase.js

@@ -1,23 +1,11 @@
 "use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var describeComponentList_1 = require("../components/util/describeComponentList");
-var EditorImage_1 = require("../EditorImage");
-var SerializableCommand_1 = require("./SerializableCommand");
+const describeComponentList_1 = __importDefault(require("../components/util/describeComponentList"));
+const EditorImage_1 = __importDefault(require("../EditorImage"));
+const SerializableCommand_1 = __importDefault(require("./SerializableCommand"));
 /**
  * Removes the given {@link AbstractComponent}s from the image.
  *
@@ -38,63 +26,57 @@ var SerializableCommand_1 = require("./SerializableCommand");
  * editor.dispatch(eraseElemsCmd);
  * ```
  */
-var Erase = /** @class */ (function (_super) {
-    __extends(Erase, _super);
-    function Erase(toRemove) {
-        var _this = _super.call(this, 'erase') || this;
+class Erase extends SerializableCommand_1.default {
+    constructor(toRemove) {
+        super('erase');
         // Clone the list
-        _this.toRemove = toRemove.map(function (elem) { return elem; });
-        _this.applied = false;
-        return _this;
+        this.toRemove = toRemove.map(elem => elem);
+        this.applied = false;
     }
-    Erase.prototype.apply = function (editor) {
-        for (var _i = 0, _a = this.toRemove; _i < _a.length; _i++) {
-            var part = _a[_i];
-            var parent_1 = editor.image.findParent(part);
-            if (parent_1) {
-                parent_1.remove();
+    apply(editor) {
+        for (const part of this.toRemove) {
+            const parent = editor.image.findParent(part);
+            if (parent) {
+                editor.image.onDestroyElement(part);
+                parent.remove();
             }
         }
         this.applied = true;
         editor.queueRerender();
-    };
-    Erase.prototype.unapply = function (editor) {
-        for (var _i = 0, _a = this.toRemove; _i < _a.length; _i++) {
-            var part = _a[_i];
+    }
+    unapply(editor) {
+        for (const part of this.toRemove) {
             if (!editor.image.findParent(part)) {
                 EditorImage_1.default.addElement(part).apply(editor);
             }
         }
         this.applied = false;
         editor.queueRerender();
-    };
-    Erase.prototype.onDrop = function (editor) {
+    }
+    onDrop(editor) {
         if (this.applied) {
-            for (var _i = 0, _a = this.toRemove; _i < _a.length; _i++) {
-                var part = _a[_i];
+            for (const part of this.toRemove) {
                 editor.image.onDestroyElement(part);
             }
         }
-    };
-    Erase.prototype.description = function (_editor, localizationTable) {
-        var _a;
+    }
+    description(_editor, localizationTable) {
         if (this.toRemove.length === 0) {
             return localizationTable.erasedNoElements;
         }
-        var description = (_a = (0, describeComponentList_1.default)(localizationTable, this.toRemove)) !== null && _a !== void 0 ? _a : localizationTable.elements;
+        const description = (0, describeComponentList_1.default)(localizationTable, this.toRemove) ?? localizationTable.elements;
         return localizationTable.eraseAction(description, this.toRemove.length);
-    };
-    Erase.prototype.serializeToJSON = function () {
-        var elemIds = this.toRemove.map(function (elem) { return elem.getId(); });
+    }
+    serializeToJSON() {
+        const elemIds = this.toRemove.map(elem => elem.getId());
         return elemIds;
-    };
-    return Erase;
-}(SerializableCommand_1.default));
-(function () {
-    SerializableCommand_1.default.register('erase', function (json, editor) {
-        var elems = json
-            .map(function (elemId) { return editor.image.lookupElement(elemId); })
-            .filter(function (elem) { return elem !== null; });
+    }
+}
+(() => {
+    SerializableCommand_1.default.register('erase', (json, editor) => {
+        const elems = json
+            .map((elemId) => editor.image.lookupElement(elemId))
+            .filter((elem) => elem !== null);
         return new Erase(elems);
     });
 })();

package/dist/cjs/commands/SerializableCommand.js

@@ -1,57 +1,42 @@
 "use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var Command_1 = require("./Command");
-var SerializableCommand = /** @class */ (function (_super) {
-    __extends(SerializableCommand, _super);
-    function SerializableCommand(commandTypeId) {
-        var _this = _super.call(this) || this;
-        _this.commandTypeId = commandTypeId;
+const Command_1 = __importDefault(require("./Command"));
+class SerializableCommand extends Command_1.default {
+    constructor(commandTypeId) {
+        super();
+        this.commandTypeId = commandTypeId;
         if (!(commandTypeId in SerializableCommand.deserializationCallbacks)) {
-            throw new Error("Command ".concat(commandTypeId, " must have a registered deserialization callback. To do this, call SerializableCommand.register."));
+            throw new Error(`Command ${commandTypeId} must have a registered deserialization callback. To do this, call SerializableCommand.register.`);
         }
-        return _this;
     }
     // Convert this command to an object that can be passed to `JSON.stringify`.
     //
     // Do not rely on the stability of the optupt of this function — it can change
     // form without a major version increase.
-    SerializableCommand.prototype.serialize = function () {
+    serialize() {
         return {
             data: this.serializeToJSON(),
             commandType: this.commandTypeId,
         };
-    };
+    }
     // Convert a `string` containing JSON data (or the output of `JSON.parse`) into a
     // `Command`.
-    SerializableCommand.deserialize = function (data, editor) {
-        var json = typeof data === 'string' ? JSON.parse(data) : data;
-        var commandType = json.commandType;
+    static deserialize(data, editor) {
+        const json = typeof data === 'string' ? JSON.parse(data) : data;
+        const commandType = json.commandType;
         if (!(commandType in SerializableCommand.deserializationCallbacks)) {
-            throw new Error("Unrecognised command type ".concat(commandType, "!"));
+            throw new Error(`Unrecognised command type ${commandType}!`);
         }
         return SerializableCommand.deserializationCallbacks[commandType](json.data, editor);
-    };
+    }
     // Register a deserialization callback. This must be called at least once for every subclass of
     // `SerializableCommand`.
-    SerializableCommand.register = function (commandTypeId, deserialize) {
+    static register(commandTypeId, deserialize) {
         SerializableCommand.deserializationCallbacks[commandTypeId] = deserialize;
-    };
-    SerializableCommand.deserializationCallbacks = {};
-    return SerializableCommand;
-}(Command_1.default));
+    }
+}
+SerializableCommand.deserializationCallbacks = {};
 exports.default = SerializableCommand;

package/dist/cjs/commands/UnresolvedCommand.js

@@ -1,43 +1,28 @@
 "use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var SerializableCommand_1 = require("./SerializableCommand");
+const SerializableCommand_1 = __importDefault(require("./SerializableCommand"));
 /**
  * A command that requires a component that may or may not be present in the editor when
  * the command is created.
  */
-var UnresolvedSerializableCommand = /** @class */ (function (_super) {
-    __extends(UnresolvedSerializableCommand, _super);
-    function UnresolvedSerializableCommand(commandId, componentID, component) {
-        var _this = _super.call(this, commandId) || this;
-        _this.component = component !== null && component !== void 0 ? component : null;
-        _this.componentID = componentID;
-        return _this;
+class UnresolvedSerializableCommand extends SerializableCommand_1.default {
+    constructor(commandId, componentID, component) {
+        super(commandId);
+        this.component = component ?? null;
+        this.componentID = componentID;
     }
-    UnresolvedSerializableCommand.prototype.resolveComponent = function (image) {
+    resolveComponent(image) {
         if (this.component) {
             return;
         }
-        var component = image.lookupElement(this.componentID);
+        const component = image.lookupElement(this.componentID);
         if (!component) {
-            throw new Error("Unable to resolve component with ID ".concat(this.componentID));
+            throw new Error(`Unable to resolve component with ID ${this.componentID}`);
         }
         this.component = component;
-    };
-    return UnresolvedSerializableCommand;
-}(SerializableCommand_1.default));
+    }
+}
 exports.default = UnresolvedSerializableCommand;

package/dist/cjs/commands/invertCommand.js

@@ -1,77 +1,55 @@
 "use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var Command_1 = require("./Command");
-var SerializableCommand_1 = require("./SerializableCommand");
+const Command_1 = __importDefault(require("./Command"));
+const SerializableCommand_1 = __importDefault(require("./SerializableCommand"));
 // Returns a command that does the opposite of the given command --- `result.apply()` calls
 // `command.unapply()` and `result.unapply()` calls `command.apply()`.
-var invertCommand = function (command) {
+const invertCommand = (command) => {
     if (command instanceof SerializableCommand_1.default) {
         // SerializableCommand that does the inverse of [command]
-        return new /** @class */ (function (_super) {
-            __extends(class_1, _super);
-            function class_1() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            class_1.prototype.serializeToJSON = function () {
+        return new class extends SerializableCommand_1.default {
+            serializeToJSON() {
                 return command.serialize();
-            };
-            class_1.prototype.apply = function (editor) {
+            }
+            apply(editor) {
                 command.unapply(editor);
-            };
-            class_1.prototype.unapply = function (editor) {
+            }
+            unapply(editor) {
                 command.unapply(editor);
-            };
-            class_1.prototype.onDrop = function (editor) {
+            }
+            onDrop(editor) {
                 command.onDrop(editor);
-            };
-            class_1.prototype.description = function (editor, localizationTable) {
+            }
+            description(editor, localizationTable) {
                 return localizationTable.inverseOf(command.description(editor, localizationTable));
-            };
-            return class_1;
-        }(SerializableCommand_1.default))('inverse');
+            }
+        }('inverse');
     }
     else {
         // Command that does the inverse of [command].
-        var result = new /** @class */ (function (_super) {
-            __extends(class_2, _super);
-            function class_2() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            class_2.prototype.apply = function (editor) {
+        const result = new class extends Command_1.default {
+            apply(editor) {
                 command.unapply(editor);
-            };
-            class_2.prototype.unapply = function (editor) {
+            }
+            unapply(editor) {
                 command.apply(editor);
-            };
-            class_2.prototype.onDrop = function (editor) {
+            }
+            onDrop(editor) {
                 command.onDrop(editor);
-            };
-            class_2.prototype.description = function (editor, localizationTable) {
+            }
+            description(editor, localizationTable) {
                 return localizationTable.inverseOf(command.description(editor, localizationTable));
-            };
-            return class_2;
-        }(Command_1.default));
+            }
+        };
         // We know that T does not extend SerializableCommand, and thus returning a Command
         // is appropriate.
         return result;
     }
 };
-SerializableCommand_1.default.register('inverse', function (data, editor) {
+SerializableCommand_1.default.register('inverse', (data, editor) => {
     return invertCommand(SerializableCommand_1.default.deserialize(data, editor));
 });
 exports.default = invertCommand;

package/dist/cjs/commands/lib.js

@@ -1,15 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uniteCommands = exports.invertCommand = exports.SerializableCommand = exports.Erase = exports.Duplicate = exports.Command = void 0;
-var Command_1 = require("./Command");
+const Command_1 = __importDefault(require("./Command"));
 exports.Command = Command_1.default;
-var Duplicate_1 = require("./Duplicate");
+const Duplicate_1 = __importDefault(require("./Duplicate"));
 exports.Duplicate = Duplicate_1.default;
-var Erase_1 = require("./Erase");
+const Erase_1 = __importDefault(require("./Erase"));
 exports.Erase = Erase_1.default;
-var invertCommand_1 = require("./invertCommand");
+const invertCommand_1 = __importDefault(require("./invertCommand"));
 exports.invertCommand = invertCommand_1.default;
-var SerializableCommand_1 = require("./SerializableCommand");
+const SerializableCommand_1 = __importDefault(require("./SerializableCommand"));
 exports.SerializableCommand = SerializableCommand_1.default;
-var uniteCommands_1 = require("./uniteCommands");
+const uniteCommands_1 = __importDefault(require("./uniteCommands"));
 exports.uniteCommands = uniteCommands_1.default;

package/dist/cjs/commands/localization.d.ts

@@ -1,4 +1,4 @@
-import Rect2 from '../math/shapes/Rect2';
+import { Rect2 } from '@js-draw/math';
 export interface CommandLocalization {
     movedLeft: string;
     movedUp: string;

package/dist/cjs/commands/localization.js

@@ -3,22 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultCommandLocalization = void 0;
 exports.defaultCommandLocalization = {
     updatedViewport: 'Transformed Viewport',
-    transformedElements: function (elemCount) { return "Transformed ".concat(elemCount, " element").concat(elemCount === 1 ? '' : 's'); },
-    resizeOutputCommand: function (newSize) { return "Resized image to ".concat(newSize.w, "x").concat(newSize.h); },
-    addElementAction: function (componentDescription) { return "Added ".concat(componentDescription); },
-    eraseAction: function (componentDescription, numElems) { return "Erased ".concat(numElems, " ").concat(componentDescription); },
-    duplicateAction: function (componentDescription, numElems) { return "Duplicated ".concat(numElems, " ").concat(componentDescription); },
-    unionOf: function (actionDescription, actionCount) { return "Union: ".concat(actionCount, " ").concat(actionDescription); },
-    inverseOf: function (actionDescription) { return "Inverse of ".concat(actionDescription); },
+    transformedElements: (elemCount) => `Transformed ${elemCount} element${elemCount === 1 ? '' : 's'}`,
+    resizeOutputCommand: (newSize) => `Resized image to ${newSize.w}x${newSize.h}`,
+    addElementAction: (componentDescription) => `Added ${componentDescription}`,
+    eraseAction: (componentDescription, numElems) => `Erased ${numElems} ${componentDescription}`,
+    duplicateAction: (componentDescription, numElems) => `Duplicated ${numElems} ${componentDescription}`,
+    unionOf: (actionDescription, actionCount) => `Union: ${actionCount} ${actionDescription}`,
+    inverseOf: (actionDescription) => `Inverse of ${actionDescription}`,
     elements: 'Elements',
     erasedNoElements: 'Erased nothing',
     duplicatedNoElements: 'Duplicated nothing',
-    rotatedBy: function (degrees) { return "Rotated by ".concat(Math.abs(degrees), " degrees ").concat(degrees < 0 ? 'clockwise' : 'counter-clockwise'); },
+    rotatedBy: (degrees) => `Rotated by ${Math.abs(degrees)} degrees ${degrees < 0 ? 'clockwise' : 'counter-clockwise'}`,
     movedLeft: 'Moved left',
     movedUp: 'Moved up',
     movedDown: 'Moved down',
     movedRight: 'Moved right',
     zoomedOut: 'Zoomed out',
     zoomedIn: 'Zoomed in',
-    selectedElements: function (count) { return "Selected ".concat(count, " element").concat(count === 1 ? '' : 's'); },
+    selectedElements: (count) => `Selected ${count} element${count === 1 ? '' : 's'}`,
 };