kritzel-stencil 0.3.16 → 0.3.18

package/dist/cjs/{schema.constants-DJQTjcy7.js → schema.constants-DrHO_CYF.js}

@@ -862,8 +862,11 @@ function findDiffStart(a, b, pos) {
         if (!childA.sameMarkup(childB))
             return pos;
         if (childA.isText && childA.text != childB.text) {
-            for (let j = 0; childA.text[j] == childB.text[j]; j++)
+            let tA = childA.text, tB = childB.text, j = 0;
+            for (; tA[j] == tB[j]; j++)
                 pos++;
+            if (j && j < tA.length && j < tB.length && surrogateHigh(tA.charCodeAt(j - 1)) && surrogateLow(tA.charCodeAt(j)))
+                pos--;
             return pos;
         }
         if (childA.content.size || childB.content.size) {
@@ -887,12 +890,17 @@ function findDiffEnd(a, b, posA, posB) {
         if (!childA.sameMarkup(childB))
             return { a: posA, b: posB };
         if (childA.isText && childA.text != childB.text) {
-            let same = 0, minSize = Math.min(childA.text.length, childB.text.length);
-            while (same < minSize && childA.text[childA.text.length - same - 1] == childB.text[childB.text.length - same - 1]) {
-                same++;
+            let tA = childA.text, tB = childB.text, iA = tA.length, iB = tB.length;
+            while (iA > 0 && iB > 0 && tA[iA - 1] == tB[iB - 1]) {
+                iA--;
+                iB--;
                 posA--;
                 posB--;
             }
+            if (iA && iB && iA < tA.length && surrogateHigh(tA.charCodeAt(iA - 1)) && surrogateLow(tA.charCodeAt(iA))) {
+                posA++;
+                posB++;
+            }
             return { a: posA, b: posB };
         }
         if (childA.content.size || childB.content.size) {
@@ -904,6 +912,8 @@ function findDiffEnd(a, b, posA, posB) {
         posB -= size;
     }
 }
+function surrogateLow(ch) { return ch >= 0xDC00 && ch < 0xE000; }
+function surrogateHigh(ch) { return ch >= 0xD800 && ch < 0xDC00; }
 
 /**
 A fragment represents a node's collection of child nodes.
@@ -1584,7 +1594,8 @@ function addRange($start, $end, depth, target) {
         addNode($end.nodeBefore, target);
 }
 function close(node, content) {
-    node.type.checkContent(content);
+    if (!node.type.validContent(content))
+        throw new ReplaceError("Invalid content for node " + node.type.name);
     return node.copy(content);
 }
 function replaceThreeWay($from, $start, $end, $to, depth) {
@@ -2895,13 +2906,12 @@ function computeAttrs(attrs, value) {
     return built;
 }
 function checkAttrs(attrs, values, type, name) {
-    for (let name in values)
-        if (!(name in attrs))
-            throw new RangeError(`Unsupported attribute ${name} for ${type} of type ${name}`);
-    for (let name in attrs) {
-        let attr = attrs[name];
-        if (attr.validate)
-            attr.validate(values[name]);
+    for (let attr in values)
+        if (!(attr in attrs))
+            throw new RangeError(`Unsupported attribute ${attr} for ${type} of type ${name}`);
+    for (let attr in attrs) {
+        if (attrs[attr].validate)
+            attrs[attr].validate(values[attr]);
     }
 }
 function initAttrs(typeName, attrs) {
@@ -3078,7 +3088,7 @@ let NodeType$1 = class NodeType {
     @internal
     */
     checkAttrs(attrs) {
-        checkAttrs(this.attrs, attrs, "node");
+        checkAttrs(this.attrs, attrs, "node", this.name);
     }
     /**
     Check whether the given mark type is allowed in this node.
@@ -3229,7 +3239,7 @@ class MarkType {
     @internal
     */
     checkAttrs(attrs) {
-        checkAttrs(this.attrs, attrs, "mark");
+        checkAttrs(this.attrs, attrs, "mark", this.name);
     }
     /**
     Queries whether a given mark type is
@@ -9664,14 +9674,14 @@ function selectionToDOM(view, force = false) {
     syncNodeSelection(view, sel);
     if (!editorOwnsSelection(view))
         return;
-    // The delayed drag selection causes issues with Cell Selections
-    // in Safari. And the drag selection delay is to workarond issues
-    // which only present in Chrome.
-    if (!force && view.input.mouseDown && view.input.mouseDown.allowDefault && chrome) {
+    // Need to delay selection normalization during a native selection
+    // drag on Chrome, or it will cause further dragging to glitch.
+    let mouseDown = view.input.mouseDown;
+    if (!force && chrome && mouseDown) {
         let domSel = view.domSelectionRange(), curSel = view.domObserver.currentSelection;
         if (domSel.anchorNode && curSel.anchorNode &&
-            isEquivalentPosition(domSel.anchorNode, domSel.anchorOffset, curSel.anchorNode, curSel.anchorOffset)) {
-            view.input.mouseDown.delayedSelectionSync = true;
+            isEquivalentPosition(domSel.anchorNode, domSel.anchorOffset, curSel.anchorNode, curSel.anchorOffset) &&
+            mouseDown.delaySelUpdate()) {
             view.domObserver.setCurSelection();
             return;
         }
@@ -10523,6 +10533,8 @@ function setSelectionOrigin(view, origin) {
     view.input.lastSelectionTime = Date.now();
 }
 function destroyInput(view) {
+    if (view.input.mouseDown)
+        view.input.mouseDown.done();
     view.domObserver.stop();
     for (let type in view.input.eventHandlers)
         view.dom.removeEventListener(type, view.input.eventHandlers[type]);
@@ -10561,7 +10573,7 @@ function dispatchEvent(view, event) {
 editHandlers.keydown = (view, _event) => {
     let event = _event;
     view.input.shiftKey = event.keyCode == 16 || event.shiftKey;
-    if (inOrNearComposition(view, event))
+    if (inOrNearComposition(view))
         return;
     view.input.lastKeyCode = event.keyCode;
     view.input.lastKeyCodeTime = Date.now();
@@ -10599,7 +10611,7 @@ editHandlers.keyup = (view, event) => {
 };
 editHandlers.keypress = (view, _event) => {
     let event = _event;
-    if (inOrNearComposition(view, event) || !event.charCode ||
+    if (inOrNearComposition(view) || !event.charCode ||
         event.ctrlKey && !event.altKey || mac$3 && event.metaKey)
         return;
     if (view.someProp("handleKeyPress", f => f(view, event))) {
@@ -10693,26 +10705,28 @@ function handleTripleClick(view, pos, inside, event) {
 function defaultTripleClick(view, inside, event) {
     if (event.button != 0)
         return false;
-    let doc = view.state.doc;
-    if (inside == -1) {
-        if (doc.inlineContent) {
-            updateSelection(view, TextSelection.create(doc, 0, doc.content.size));
-            return true;
-        }
+    let selection = selectionForTripleClick(view, inside, true), doc = view.state.doc;
+    if (!selection)
         return false;
-    }
+    updateSelection(view, selection);
+    if (selection instanceof TextSelection && doc.eq(view.state.doc))
+        view.input.mouseDown = new TripleClickDrag(view, selection);
+    return true;
+}
+function selectionForTripleClick(view, inside, selectNodes) {
+    let doc = view.state.doc;
+    if (inside == -1)
+        return doc.inlineContent ? TextSelection.create(doc, 0, doc.content.size) : null;
     let $pos = doc.resolve(inside);
     for (let i = $pos.depth + 1; i > 0; i--) {
         let node = i > $pos.depth ? $pos.nodeAfter : $pos.node(i);
         let nodePos = $pos.before(i);
         if (node.inlineContent)
-            updateSelection(view, TextSelection.create(doc, nodePos + 1, nodePos + 1 + node.content.size));
-        else if (NodeSelection.isSelectable(node))
-            updateSelection(view, NodeSelection.create(doc, nodePos));
-        else
-            continue;
-        return true;
+            return TextSelection.create(doc, nodePos + 1, nodePos + 1 + node.content.size);
+        else if (selectNodes && NodeSelection.isSelectable(node))
+            return NodeSelection.create(doc, nodePos);
     }
+    return null;
 }
 function forceDOMFlush(view) {
     return endComposition(view);
@@ -10731,13 +10745,13 @@ handlers.mousedown = (view, _event) => {
             type = "tripleClick";
     }
     view.input.lastClick = { time: now, x: event.clientX, y: event.clientY, type, button: event.button };
+    if (view.input.mouseDown)
+        view.input.mouseDown.done();
     let pos = view.posAtCoords(eventCoords(event));
     if (!pos)
         return;
     if (type == "singleClick") {
-        if (view.input.mouseDown)
-            view.input.mouseDown.done();
-        view.input.mouseDown = new MouseDown(view, pos, event, !!flushed);
+        view.input.mouseDown = new LeftMouseDown(view, pos, event, !!flushed);
     }
     else if ((type == "doubleClick" ? handleDoubleClick : handleTripleClick)(view, pos.pos, pos.inside, event)) {
         event.preventDefault();
@@ -10747,13 +10761,34 @@ handlers.mousedown = (view, _event) => {
     }
 };
 class MouseDown {
-    constructor(view, pos, event, flushed) {
+    constructor(view) {
         this.view = view;
+        this.mightDrag = null;
+        view.root.addEventListener("mouseup", this.up = this.up.bind(this));
+        view.root.addEventListener("mousemove", this.move = this.move.bind(this));
+    }
+    up(event) {
+        this.done();
+    }
+    move(event) {
+        if (event.buttons == 0)
+            this.done();
+    }
+    done() {
+        this.view.root.removeEventListener("mouseup", this.up);
+        this.view.root.removeEventListener("mousemove", this.move);
+        if (this.view.input.mouseDown == this)
+            this.view.input.mouseDown = null;
+    }
+    delaySelUpdate() { return false; }
+}
+class LeftMouseDown extends MouseDown {
+    constructor(view, pos, event, flushed) {
+        super(view);
         this.pos = pos;
         this.event = event;
         this.flushed = flushed;
         this.delayedSelectionSync = false;
-        this.mightDrag = null;
         this.startDoc = view.state.doc;
         this.selectNode = !!event[selectNodeModifier];
         this.allowDefault = event.shiftKey;
@@ -10791,13 +10826,10 @@ class MouseDown {
                 }, 20);
             this.view.domObserver.start();
         }
-        view.root.addEventListener("mouseup", this.up = this.up.bind(this));
-        view.root.addEventListener("mousemove", this.move = this.move.bind(this));
         setSelectionOrigin(view, "pointer");
     }
     done() {
-        this.view.root.removeEventListener("mouseup", this.up);
-        this.view.root.removeEventListener("mousemove", this.move);
+        super.done();
         if (this.mightDrag && this.target) {
             this.view.domObserver.stop();
             if (this.mightDrag.addAttr)
@@ -10807,8 +10839,10 @@ class MouseDown {
             this.view.domObserver.start();
         }
         if (this.delayedSelectionSync)
-            setTimeout(() => selectionToDOM(this.view));
-        this.view.input.mouseDown = null;
+            setTimeout(() => {
+                if (!this.view.isDestroyed)
+                    selectionToDOM(this.view);
+            });
     }
     up(event) {
         this.done();
@@ -10847,14 +10881,41 @@ class MouseDown {
     move(event) {
         this.updateAllowDefault(event);
         setSelectionOrigin(this.view, "pointer");
-        if (event.buttons == 0)
-            this.done();
+        super.move(event);
     }
     updateAllowDefault(event) {
         if (!this.allowDefault && (Math.abs(this.event.x - event.clientX) > 4 ||
             Math.abs(this.event.y - event.clientY) > 4))
             this.allowDefault = true;
     }
+    delaySelUpdate() {
+        if (!this.allowDefault)
+            return false;
+        this.delayedSelectionSync = true;
+        return true;
+    }
+}
+class TripleClickDrag extends MouseDown {
+    constructor(view, startSelection) {
+        super(view);
+        this.startSelection = startSelection;
+        this.startDoc = view.state.doc;
+    }
+    move(event) {
+        if (event.buttons == 0 || this.view.isDestroyed || !this.view.state.doc.eq(this.startDoc)) {
+            this.done();
+            return;
+        }
+        event.preventDefault();
+        setSelectionOrigin(this.view, "pointer");
+        let pos = this.view.posAtCoords(eventCoords(event));
+        let target = pos && selectionForTripleClick(this.view, pos.inside, false);
+        if (!target)
+            return;
+        let { doc } = this.view.state, start = this.startSelection;
+        let [anchor, head] = target.from < start.from ? [start.to, target.from] : [start.from, target.to];
+        updateSelection(this.view, TextSelection.create(doc, anchor, head));
+    }
 }
 handlers.touchstart = view => {
     view.input.lastTouch = Date.now();
@@ -10879,7 +10940,7 @@ function inOrNearComposition(view, event) {
     // This guards against the case where compositionend is triggered without the keyboard
     // (e.g. character confirmation may be done with the mouse), and keydown is triggered
     // afterwards- we wouldn't want to ignore the keydown event in this case.
-    if (safari && Math.abs(event.timeStamp - view.input.compositionEndedAt) < 500) {
+    if (safari && Math.abs(Date.now() - view.input.compositionEndedAt) < 500) {
         view.input.compositionEndedAt = -2e8;
         return true;
     }
@@ -10938,7 +10999,7 @@ function selectionBeforeUneditable(view) {
 editHandlers.compositionend = (view, event) => {
     if (view.composing) {
         view.input.composing = false;
-        view.input.compositionEndedAt = event.timeStamp;
+        view.input.compositionEndedAt = Date.now();
         view.input.compositionPendingChanges = view.domObserver.pendingRecords().length ? view.input.compositionID : 0;
         view.input.compositionNode = null;
         if (view.input.badSafariComposition)
@@ -10957,7 +11018,7 @@ function scheduleComposeEnd(view, delay) {
 function clearComposition(view) {
     if (view.composing) {
         view.input.composing = false;
-        view.input.compositionEndedAt = timestampFromCustomEvent();
+        view.input.compositionEndedAt = Date.now();
     }
     while (view.input.compositionNodes.length > 0)
         view.input.compositionNodes.pop().markParentsDirty();
@@ -10983,11 +11044,6 @@ function findCompositionNode(view) {
     }
     return textBefore || textAfter;
 }
-function timestampFromCustomEvent() {
-    let event = document.createEvent("Event");
-    event.initEvent("event", true, true);
-    return event.timeStamp;
-}
 /**
 @internal
 */
@@ -12144,7 +12200,10 @@ class DOMObserver {
                 }
             }
         }
-        if (added.some(n => n.nodeName == "BR") && (view.input.lastKeyCode == 8 || view.input.lastKeyCode == 46)) {
+        if (added.some(n => n.nodeName == "BR") &&
+            (view.input.lastKeyCode == 8 || view.input.lastKeyCode == 46 ||
+                chrome && (view.composing || view.input.compositionEndedAt > Date.now() - 50) &&
+                    mutations.some(m => m.type == "childList" && m.removedNodes.length))) {
             // Browsers sometimes insert a bogus break node if you
             // backspace out the last bit of text before an inline-flex node (#1552)
             for (let node of added)
@@ -12700,38 +12759,28 @@ function skipClosingAndOpening($pos, fromEnd, mayOpen) {
     return end;
 }
 function findDiff(a, b, pos, preferredPos, preferredSide) {
-    let start = a.findDiffStart(b, pos);
+    let start = a.findDiffStart(b, pos), lenA = pos + a.size, lenB = pos + b.size;
     if (start == null)
         return null;
-    let { a: endA, b: endB } = a.findDiffEnd(b, pos + a.size, pos + b.size);
+    let { a: endA, b: endB } = a.findDiffEnd(b, lenA, lenB);
     if (preferredSide == "end") {
         let adjust = Math.max(0, start - Math.min(endA, endB));
         preferredPos -= endA + adjust - start;
     }
-    if (endA < start && a.size < b.size) {
+    if (endA < start && lenA < lenB) {
         let move = preferredPos <= start && preferredPos >= endA ? start - preferredPos : 0;
         start -= move;
-        if (start && start < b.size && isSurrogatePair(b.textBetween(start - 1, start + 1)))
-            start += move ? 1 : -1;
         endB = start + (endB - endA);
         endA = start;
     }
     else if (endB < start) {
         let move = preferredPos <= start && preferredPos >= endB ? start - preferredPos : 0;
         start -= move;
-        if (start && start < a.size && isSurrogatePair(a.textBetween(start - 1, start + 1)))
-            start += move ? 1 : -1;
         endA = start + (endA - endB);
         endB = start;
     }
     return { start, endA, endB };
 }
-function isSurrogatePair(str) {
-    if (str.length != 2)
-        return false;
-    let a = str.charCodeAt(0), b = str.charCodeAt(1);
-    return a >= 0xDC00 && a <= 0xDFFF && b >= 0xD800 && b <= 0xDBFF;
-}
 /**
 An editor view manages the DOM structure that represents an
 editable document. Its state and behavior are determined by its
@@ -12923,9 +12972,10 @@ class EditorView {
             // a DOM selection change and the "selectionchange" event for it
             // can cause a spurious DOM selection update, disrupting mouse
             // drag selection.
+            let mouseDown = this.input.mouseDown;
             if (forceSelUpdate ||
-                !(this.input.mouseDown && this.domObserver.currentSelection.eq(this.domSelectionRange()) &&
-                    anchorInRightPlace(this))) {
+                !(mouseDown && this.domObserver.currentSelection.eq(this.domSelectionRange()) &&
+                    anchorInRightPlace(this) && mouseDown.delaySelUpdate())) {
                 selectionToDOM(this, forceSelUpdate);
             }
             else {
@@ -14622,6 +14672,24 @@ const lightTheme = {
         buttonHoverBackgroundColor: 'hsl(0, 0%, 0%, 4.3%)',
         separatorColor: 'hsl(0, 0%, 0%, 8%)',
     },
+    watermark: {
+        background: 'rgba(255, 255, 255, 0.6)',
+        boxShadow: '0 1px 2px rgba(0, 0, 0, 0.12)',
+        color: 'rgba(60, 60, 60, 0.75)',
+    },
+    zoomPanel: {
+        backgroundColor: '#ffffff',
+        border: '1px solid #ebebeb',
+        borderRadius: '12px',
+        boxShadow: '0 0 3px rgba(0, 0, 0, 0.08)',
+        buttonActiveBackgroundColor: 'hsl(0, 0%, 0%, 8.6%)',
+        buttonBorderRadius: '8px',
+        buttonHoverBackgroundColor: 'hsl(0, 0%, 0%, 4.3%)',
+        buttonSize: '32px',
+        gap: '4px',
+        iconColor: '#000000',
+        padding: '4px',
+    },
 };
 
 /**
@@ -14899,6 +14967,24 @@ const darkTheme = {
         buttonHoverBackgroundColor: 'hsl(0, 0%, 100%, 8%)',
         separatorColor: 'hsl(0, 0%, 100%, 12%)',
     },
+    watermark: {
+        background: 'rgba(40, 40, 40, 0.6)',
+        boxShadow: '0 1px 2px rgba(0, 0, 0, 0.35)',
+        color: 'rgba(220, 220, 220, 0.8)',
+    },
+    zoomPanel: {
+        backgroundColor: '#2a2a2a',
+        border: '1px solid #3a3a3a',
+        borderRadius: '12px',
+        boxShadow: '0 0 3px rgba(0, 0, 0, 0.4)',
+        buttonActiveBackgroundColor: 'hsl(0, 0%, 100%, 12%)',
+        buttonBorderRadius: '8px',
+        buttonHoverBackgroundColor: 'hsl(0, 0%, 100%, 8%)',
+        buttonSize: '32px',
+        gap: '4px',
+        iconColor: '#e0e0e0',
+        padding: '4px',
+    },
 };
 
 class ThemeHelper {
@@ -14972,7 +15058,7 @@ class ThemeHelper {
 }
 
 /** Key used to store the settings object in localStorage. */
-const SETTINGS_STORAGE_KEY = 'kritzel-settings';
+const SETTINGS_STORAGE_KEY$1 = 'kritzel-settings';
 /** Default theme used when no stored preference exists. */
 const DEFAULT_THEME = 'light';
 /**
@@ -14999,7 +15085,7 @@ class KritzelThemeManager {
      */
     constructor(core) {
         this._core = core;
-        this._storageKey = core.editorId ? `${SETTINGS_STORAGE_KEY}-${core.editorId}` : SETTINGS_STORAGE_KEY;
+        this._storageKey = core.editorId ? `${SETTINGS_STORAGE_KEY$1}-${core.editorId}` : SETTINGS_STORAGE_KEY$1;
         this._themeRegistry.set('light', lightTheme);
         this._themeRegistry.set('dark', darkTheme);
         this._currentTheme = this.getStoredTheme();
@@ -15115,7 +15201,7 @@ class KritzelThemeManager {
         if (typeof localStorage === 'undefined') {
             return DEFAULT_THEME;
         }
-        const stored = localStorage.getItem(SETTINGS_STORAGE_KEY);
+        const stored = localStorage.getItem(SETTINGS_STORAGE_KEY$1);
         if (!stored) {
             return DEFAULT_THEME;
         }
@@ -15279,6 +15365,15 @@ class KritzelColorHelper {
     }
 }
 
+class KritzelMathHelper {
+    static average(a, b) {
+        return (a + b) / 2;
+    }
+    static degreesToRadians(degrees) {
+        return degrees * (Math.PI / 180);
+    }
+}
+
 /**
  * Represents a text object on the canvas that supports rich text editing via ProseMirror.
  * Extends the base object class to inherit common object properties and behaviors.
@@ -15343,6 +15438,7 @@ class KritzelText extends KritzelBaseObject {
      */
     constructor(config) {
         super();
+        this.rotation = KritzelMathHelper.degreesToRadians(config?.rotation ?? 0);
         // Always create the editor so setContent() works immediately
         this.editor = this.createEditor();
         if (config) {
@@ -15381,7 +15477,7 @@ class KritzelText extends KritzelBaseObject {
      * @param scale - Optional scale factor (defaults to current viewport scale).
      * @returns A new, fully initialized KritzelText instance.
      */
-    static create(core, fontSize, fontFamily, scale) {
+    static create(core, fontSize, fontFamily, scale, rotation) {
         const object = new KritzelText();
         object._core = core;
         object.id = object.generateId();
@@ -15391,6 +15487,7 @@ class KritzelText extends KritzelBaseObject {
         object.fontFamily = fontFamily || 'Arial';
         object.translateX = 0;
         object.translateY = 0;
+        object.rotation = KritzelMathHelper.degreesToRadians(rotation ?? 0);
         const coreScale = core.store.state.scale;
         const effectiveScale = coreScale < 0 ? coreScale : 1;
         object.width = object.initialWidth / effectiveScale;
@@ -15742,12 +15839,6 @@ function requireCjs () {
 
 var cjsExports = requireCjs();
 
-class KritzelMathHelper {
-    static average(a, b) {
-        return (a + b) / 2;
-    }
-}
-
 class KritzelPath extends KritzelBaseObject {
     __class__ = 'KritzelPath';
     points;
@@ -15790,6 +15881,7 @@ class KritzelPath extends KritzelBaseObject {
         this.points = config?.points ?? [];
         this.translateX = config?.translateX ?? 0;
         this.translateY = config?.translateY ?? 0;
+        this.rotation = KritzelMathHelper.degreesToRadians(config?.rotation ?? 0);
         this.scale = config?.scale ?? 1;
         this.strokeWidth = config?.strokeWidth ?? 8;
         this.fill = config?.fill ?? { light: '#000000', dark: '#ffffff' };
@@ -15813,6 +15905,7 @@ class KritzelPath extends KritzelBaseObject {
         object.points = options?.points ?? [];
         object.translateX = options?.translateX ?? 0;
         object.translateY = options?.translateY ?? 0;
+        object.rotation = KritzelMathHelper.degreesToRadians(options?.rotation ?? 0);
         object.scale = options?.scale ?? 1;
         object.strokeWidth = options?.strokeWidth ?? 8;
         object.fill = options?.fill ?? { light: '#000000', dark: '#ffffff' };
@@ -15862,8 +15955,12 @@ class KritzelPath extends KritzelBaseObject {
         this.height = Math.max(...this.points.map(p => p[1])) - Math.min(...this.points.map(p => p[1])) + this.strokeWidth;
         this.x = Math.min(...this.points.map(p => p[0])) - this.strokeWidth / 2;
         this.y = Math.min(...this.points.map(p => p[1])) - this.strokeWidth / 2;
-        this.translateX = x;
-        this.translateY = y;
+        if (x !== null) {
+            this.translateX = x;
+        }
+        if (y !== null) {
+            this.translateY = y;
+        }
         this._adjustedPoints = null;
         this._core.store.objects.update(this);
     }
@@ -16069,19 +16166,14 @@ class KritzelPath extends KritzelBaseObject {
     }
     /**
      * Updates width, height, x, y, translateX, and translateY based on current points.
-     * Accounts for rotation and stroke width in the calculations.
+     * Uses the unrotated local points and stroke width for base dimensions.
      * Called during initial setup to establish the path's dimensions and position.
      */
     updateDimensions() {
-        const rotatedPoints = this.points.map(([x, y]) => {
-            const rotatedX = x * Math.cos(this.rotation) - y * Math.sin(this.rotation);
-            const rotatedY = x * Math.sin(this.rotation) + y * Math.cos(this.rotation);
-            return [rotatedX, rotatedY];
-        });
-        const minX = Math.min(...rotatedPoints.map(p => p[0] - this.strokeWidth / 2));
-        const minY = Math.min(...rotatedPoints.map(p => p[1] - this.strokeWidth / 2));
-        const maxX = Math.max(...rotatedPoints.map(p => p[0] + this.strokeWidth / 2));
-        const maxY = Math.max(...rotatedPoints.map(p => p[1] + this.strokeWidth / 2));
+        const minX = Math.min(...this.points.map(p => p[0])) - this.strokeWidth / 2;
+        const minY = Math.min(...this.points.map(p => p[1])) - this.strokeWidth / 2;
+        const maxX = Math.max(...this.points.map(p => p[0])) + this.strokeWidth / 2;
+        const maxY = Math.max(...this.points.map(p => p[1])) + this.strokeWidth / 2;
         this.width = maxX - minX + this.lineSlack;
         this.height = maxY - minY + this.lineSlack;
         this.x = minX;
@@ -17148,6 +17240,7 @@ class KritzelImage extends KritzelBaseObject {
         this.y = config?.y || 0;
         this.translateX = config?.translateX || 0;
         this.translateY = config?.translateY || 0;
+        this.rotation = KritzelMathHelper.degreesToRadians(config?.rotation ?? 0);
         this.scale = config?.scale || 1;
         this.width = config?.width || 0;
         this.height = config?.height || 0;
@@ -17161,17 +17254,18 @@ class KritzelImage extends KritzelBaseObject {
      * @param core - The KritzelCore instance providing access to store and state management.
      * @returns A new KritzelImage instance configured with the core context.
      */
-    static create(core) {
-        const object = new KritzelImage();
+    static create(core, config) {
+        const object = new KritzelImage(config);
         object._core = core;
         object.id = object.generateId();
         object.workspaceId = core.store.state.activeWorkspace.id;
         object.userId = core.user?.id;
-        object.x = 0;
-        object.y = 0;
-        object.translateX = 0;
-        object.translateY = 0;
-        object.scale = object._core.store.state.scale;
+        object.x = config?.x ?? 0;
+        object.y = config?.y ?? 0;
+        object.translateX = config?.translateX ?? 0;
+        object.translateY = config?.translateY ?? 0;
+        object.scale = config?.scale ?? object._core.store.state.scale;
+        object.rotation = KritzelMathHelper.degreesToRadians(config?.rotation ?? 0);
         object.zIndex = core.store.currentZIndex;
         return object;
     }
@@ -17550,6 +17644,7 @@ class KritzelLine extends KritzelBaseObject {
         this.controlY = config?.controlY;
         this.translateX = config?.translateX ?? 0;
         this.translateY = config?.translateY ?? 0;
+        this.rotation = KritzelMathHelper.degreesToRadians(config?.rotation ?? 0);
         this.scale = config?.scale ?? 1;
         this.strokeWidth = config?.strokeWidth ?? 4;
         this.stroke = config?.stroke ?? { light: '#000000', dark: '#ffffff' };
@@ -17580,6 +17675,7 @@ class KritzelLine extends KritzelBaseObject {
         object.controlY = options?.controlY;
         object.translateX = options?.translateX ?? 0;
         object.translateY = options?.translateY ?? 0;
+        object.rotation = KritzelMathHelper.degreesToRadians(options?.rotation ?? 0);
         object.scale = options?.scale ?? 1;
         object.strokeWidth = options?.strokeWidth ?? 4;
         object.stroke = options?.stroke ?? { light: '#000000', dark: '#ffffff' };
@@ -18274,6 +18370,10 @@ class KritzelClassHelper {
  */
 class KritzelGroup extends KritzelBaseObject {
     __class__ = 'KritzelGroup';
+    constructor(config) {
+        super();
+        this.rotation = KritzelMathHelper.degreesToRadians(config?.rotation ?? 0);
+    }
     /**
      * IDs of child objects within this group.
      * Children can be any KritzelBaseObject, including other KritzelGroups for nesting.
@@ -18325,8 +18425,8 @@ class KritzelGroup extends KritzelBaseObject {
      * @param core - The KritzelCore instance providing access to store and state management.
      * @returns A new KritzelGroup instance configured with the core context.
      */
-    static create(core) {
-        const group = new KritzelGroup();
+    static create(core, config) {
+        const group = new KritzelGroup(config);
         group._core = core;
         group.id = group.generateId();
         group.workspaceId = core.store.state.activeWorkspace.id;
@@ -18915,6 +19015,7 @@ class KritzelShape extends KritzelBaseObject {
             this.y = config.y ?? 0;
             this.translateX = config.translateX ?? 0;
             this.translateY = config.translateY ?? 0;
+            this.rotation = KritzelMathHelper.degreesToRadians(config.rotation ?? 0);
             this.width = config.width ?? 100;
             this.height = config.height ?? 100;
             this.shapeType = config.shapeType ?? exports.ShapeType.Rectangle;
@@ -18946,6 +19047,7 @@ class KritzelShape extends KritzelBaseObject {
         object.y = config?.y ?? 0;
         object.translateX = config?.translateX ?? 0;
         object.translateY = config?.translateY ?? 0;
+        object.rotation = KritzelMathHelper.degreesToRadians(config?.rotation ?? 0);
         object.width = config?.width ?? 100;
         object.height = config?.height ?? 100;
         object.shapeType = config?.shapeType ?? exports.ShapeType.Rectangle;
@@ -19444,71 +19546,6 @@ class KritzelShape extends KritzelBaseObject {
     }
 }
 
-exports.KritzelMouseButton = void 0;
-(function (KritzelMouseButton) {
-    KritzelMouseButton[KritzelMouseButton["Left"] = 0] = "Left";
-    KritzelMouseButton[KritzelMouseButton["Middle"] = 1] = "Middle";
-    KritzelMouseButton[KritzelMouseButton["Right"] = 2] = "Right";
-})(exports.KritzelMouseButton || (exports.KritzelMouseButton = {}));
-
-class KritzelEventHelper {
-    static isRightClick(ev) {
-        return ev.button === exports.KritzelMouseButton.Right;
-    }
-    static isLeftClick(ev) {
-        return ev.button === exports.KritzelMouseButton.Left;
-    }
-    static isPointerEventOnContextMenu(event) {
-        const path = event.composedPath();
-        const contextMenu = path.find(element => element.classList && element.classList.contains('context-menu'));
-        return !!contextMenu;
-    }
-    static onLongPress(event, onSuccess, onCancel) {
-        if (event.pointerType !== 'touch') {
-            onCancel?.();
-            return () => { };
-        }
-        const startX = event.clientX;
-        const startY = event.clientY;
-        const target = event.target;
-        if (!target) {
-            onCancel?.();
-            return () => { };
-        }
-        const longPressTimeout = 400;
-        const moveThreshold = 10;
-        const timer = setTimeout(() => {
-            removeListeners();
-            onSuccess(event);
-        }, longPressTimeout);
-        const cancel = () => {
-            clearTimeout(timer);
-            removeListeners();
-            onCancel?.();
-        };
-        const onPointerMove = (e) => {
-            if (Math.abs(e.clientX - startX) > moveThreshold || Math.abs(e.clientY - startY) > moveThreshold) {
-                cancel();
-            }
-        };
-        const onPointerUp = () => {
-            cancel();
-        };
-        const onPointerCancel = () => {
-            cancel();
-        };
-        const removeListeners = () => {
-            target.removeEventListener('pointermove', onPointerMove);
-            target.removeEventListener('pointerup', onPointerUp);
-            target.removeEventListener('pointercancel', onPointerCancel);
-        };
-        target.addEventListener('pointermove', onPointerMove, { passive: true });
-        target.addEventListener('pointerup', onPointerUp, { once: true });
-        target.addEventListener('pointercancel', onPointerCancel, { once: true });
-        return cancel;
-    }
-}
-
 /**
  * Abstract base class for all drawing tools in Kritzel.
  * Provides common functionality and defines the interface that all tools must implement.
@@ -19597,6 +19634,71 @@ class KritzelBaseTool {
     }
 }
 
+exports.KritzelMouseButton = void 0;
+(function (KritzelMouseButton) {
+    KritzelMouseButton[KritzelMouseButton["Left"] = 0] = "Left";
+    KritzelMouseButton[KritzelMouseButton["Middle"] = 1] = "Middle";
+    KritzelMouseButton[KritzelMouseButton["Right"] = 2] = "Right";
+})(exports.KritzelMouseButton || (exports.KritzelMouseButton = {}));
+
+class KritzelEventHelper {
+    static isRightClick(ev) {
+        return ev.button === exports.KritzelMouseButton.Right;
+    }
+    static isLeftClick(ev) {
+        return ev.button === exports.KritzelMouseButton.Left;
+    }
+    static isPointerEventOnContextMenu(event) {
+        const path = event.composedPath();
+        const contextMenu = path.find(element => element.classList && element.classList.contains('context-menu'));
+        return !!contextMenu;
+    }
+    static onLongPress(event, onSuccess, onCancel) {
+        if (event.pointerType !== 'touch') {
+            onCancel?.();
+            return () => { };
+        }
+        const startX = event.clientX;
+        const startY = event.clientY;
+        const target = event.target;
+        if (!target) {
+            onCancel?.();
+            return () => { };
+        }
+        const longPressTimeout = 400;
+        const moveThreshold = 10;
+        const timer = setTimeout(() => {
+            removeListeners();
+            onSuccess(event);
+        }, longPressTimeout);
+        const cancel = () => {
+            clearTimeout(timer);
+            removeListeners();
+            onCancel?.();
+        };
+        const onPointerMove = (e) => {
+            if (Math.abs(e.clientX - startX) > moveThreshold || Math.abs(e.clientY - startY) > moveThreshold) {
+                cancel();
+            }
+        };
+        const onPointerUp = () => {
+            cancel();
+        };
+        const onPointerCancel = () => {
+            cancel();
+        };
+        const removeListeners = () => {
+            target.removeEventListener('pointermove', onPointerMove);
+            target.removeEventListener('pointerup', onPointerUp);
+            target.removeEventListener('pointercancel', onPointerCancel);
+        };
+        target.addEventListener('pointermove', onPointerMove, { passive: true });
+        target.addEventListener('pointerup', onPointerUp, { once: true });
+        target.addEventListener('pointercancel', onPointerCancel, { once: true });
+        return cancel;
+    }
+}
+
 const DEFAULT_STROKE_SIZES = [4, 6, 8, 12, 16, 24];
 const DEFAULT_FONT_SIZES = [8, 10, 12, 16, 20, 24];
 
@@ -19625,7 +19727,7 @@ class KritzelBrushTool extends KritzelBaseTool {
      * websocket traffic without visible quality loss — `perfect-freehand`
      * already smooths the rendered stroke.
      */
-    static MIN_POINT_DISTANCE_PX = 5;
+    static MIN_POINT_DISTANCE_PX = 3;
     /** Tracks the ID of the path currently being drawn */
     _currentPathId = null;
     /**
@@ -19839,6 +19941,10 @@ class KritzelBrushTool extends KritzelBaseTool {
  */
 class KritzelSelectionGroup extends KritzelBaseObject {
     __class__ = 'KritzelSelectionGroup';
+    constructor(config) {
+        super();
+        this.rotation = KritzelMathHelper.degreesToRadians(config?.rotation ?? 0);
+    }
     // Store only object IDs instead of full objects
     _objectIds = [];
     // Cached objects array - invalidated when objectIds changes
@@ -19922,8 +20028,8 @@ class KritzelSelectionGroup extends KritzelBaseObject {
      * @param core - The KritzelCore instance to associate with this selection group
      * @returns A new KritzelSelectionGroup instance configured with default settings
      */
-    static create(core) {
-        const object = new KritzelSelectionGroup();
+    static create(core, config) {
+        const object = new KritzelSelectionGroup(config);
         object._core = core;
         object.id = object.generateId();
         object.workspaceId = core.store.state.activeWorkspace.id;
@@ -21540,6 +21646,7 @@ KritzelIconRegistry.registerIcons({
     'undo': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-undo-icon lucide-undo"><path d="M3 7v6h6"/><path d="M21 17a9 9 0 0 0-9-9 9 9 0 0 0-6 2.3L3 13"/></svg>',
     'redo': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-redo-icon lucide-redo"><path d="M21 7v6h-6"/><path d="M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7"/></svg>',
     'plus': '<svg  width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-plus-icon lucide-plus"><path d="M5 12h14"/><path d="M12 5v14"/></svg>',
+    'minus': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-minus-icon lucide-minus"><path d="M5 12h14"/></svg>',
     'ellipsis-vertical': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-ellipsis-vertical-icon lucide-ellipsis-vertical"><circle cx="12" cy="12" r="1"/><circle cx="12" cy="5" r="1"/><circle cx="12" cy="19" r="1"/></svg>',
     'x': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-x-icon lucide-x"><path d="M18 6 6 18"/><path d="m6 6 12 12"/></svg>',
     'check': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-check-icon lucide-check"><path d="M20 6 9 17l-5-5"/></svg>',
@@ -28313,6 +28420,890 @@ class KritzelAnchorManager {
     }
 }
 
+/**
+ * Pure static utilities for localization term resolution.
+ */
+class LocalizationHelper {
+    /**
+     * Interpolates `{placeholder}` tokens in a term template with the provided
+     * variables. Tokens without a matching variable are left untouched.
+     *
+     * @param template - The raw term string, e.g. `'Expires {date}'`
+     * @param vars - Map of placeholder names to replacement values
+     * @returns The interpolated string
+     *
+     * @example
+     * LocalizationHelper.interpolate('Hello {name}', { name: 'Ada' }); // 'Hello Ada'
+     */
+    static interpolate(template, vars) {
+        if (!vars) {
+            return template;
+        }
+        return template.replace(/\{(\w+)\}/g, (match, key) => {
+            const value = vars[key];
+            return value === undefined || value === null ? match : String(value);
+        });
+    }
+}
+
+/**
+ * Built-in English locale (default). Provides a complete set of term values
+ * that act as the ultimate fallback when other locales omit a key.
+ */
+const EN_LOCALE = {
+    code: 'en',
+    label: 'English',
+    terms: {
+        // Context menu
+        'menu.copy': 'Copy',
+        'menu.cut': 'Cut',
+        'menu.paste': 'Paste',
+        'menu.selectAll': 'Select All',
+        'menu.order': 'Order',
+        'menu.bringToFront': 'Bring to Front',
+        'menu.sendToBack': 'Send to Back',
+        'menu.moveUp': 'Move Up',
+        'menu.moveDown': 'Move Down',
+        'menu.align': 'Align',
+        'menu.alignLeft': 'Align Left',
+        'menu.alignCenterHorizontal': 'Align Center Horizontally',
+        'menu.alignRight': 'Align Right',
+        'menu.alignTop': 'Align Top',
+        'menu.alignCenterVertical': 'Align Center Vertically',
+        'menu.alignBottom': 'Align Bottom',
+        'menu.group': 'Group',
+        'menu.ungroup': 'Ungroup',
+        'menu.export': 'Export',
+        'menu.exportAsSvg': 'Export as SVG',
+        'menu.exportAsPng': 'Export as PNG',
+        'menu.delete': 'Delete',
+        // More menu
+        'menu.share': 'Share',
+        'menu.import': 'Import',
+        'menu.settings': 'Settings',
+        'menu.logout': 'Logout',
+        // Settings dialog
+        'settings.dialogTitle': 'Settings',
+        'settings.categories.general': 'General',
+        'settings.categories.viewport': 'Viewport',
+        'settings.categories.shortcuts': 'Keyboard Shortcuts',
+        'settings.categories.developer': 'Developer Options',
+        'settings.categories.about': 'About',
+        'settings.general.title': 'General Settings',
+        'settings.general.theme.label': 'Theme',
+        'settings.general.theme.description': 'Select a registered color theme for the editor interface.',
+        'settings.general.language.label': 'Language',
+        'settings.general.language.description': 'Select the display language for the editor interface.',
+        'settings.general.lockDrawingScale.label': 'Lock Drawing Scale',
+        'settings.general.lockDrawingScale.description': 'When enabled, drawn objects maintain a fixed visual size regardless of the current zoom level.',
+        'settings.viewport.title': 'Viewport Settings',
+        'settings.viewport.minZoom.label': 'Minimum Zoom Level',
+        'settings.viewport.minZoom.description': 'Sets the minimum zoom level. Lower values allow zooming out further to see more of the canvas.',
+        'settings.viewport.maxZoom.label': 'Maximum Zoom Level',
+        'settings.viewport.maxZoom.description': 'Sets the maximum zoom level. Higher values allow zooming in closer for detailed work.',
+        'settings.viewport.boundaryLeft.label': 'Viewport Boundary Left',
+        'settings.viewport.boundaryLeft.description': 'Left boundary in world coordinates. Set to limit how far left the viewport can pan.',
+        'settings.viewport.boundaryRight.label': 'Viewport Boundary Right',
+        'settings.viewport.boundaryRight.description': 'Right boundary in world coordinates. Set to limit how far right the viewport can pan.',
+        'settings.viewport.boundaryTop.label': 'Viewport Boundary Top',
+        'settings.viewport.boundaryTop.description': 'Top boundary in world coordinates. Set to limit how far up the viewport can pan.',
+        'settings.viewport.boundaryBottom.label': 'Viewport Boundary Bottom',
+        'settings.viewport.boundaryBottom.description': 'Bottom boundary in world coordinates. Set to limit how far down the viewport can pan.',
+        'settings.viewport.boundaryPlaceholder': 'Infinite',
+        'settings.shortcuts.title': 'Keyboard Shortcuts',
+        'settings.developer.title': 'Developer Options',
+        'settings.developer.showViewportInfo.label': 'Show Viewport Info',
+        'settings.developer.showViewportInfo.description': 'Display viewport debug information such as position, zoom level, and boundaries.',
+        'settings.developer.showObjectInfo.label': 'Show Object Info',
+        'settings.developer.showObjectInfo.description': 'Display debug information about objects on the canvas.',
+        'settings.developer.showSyncProviderInfo.label': 'Show Sync Provider Info',
+        'settings.developer.showSyncProviderInfo.description': 'Display debug information about the sync provider connection status.',
+        'settings.developer.showMigrationInfo.label': 'Show Migration Info',
+        'settings.developer.showMigrationInfo.description': 'Display debug information about data migrations.',
+        'settings.about.title': 'About',
+        'settings.about.description': 'Kritzel - A drawing application',
+        // Export dialog
+        'export.dialogTitle': 'Export',
+        'export.tabs.viewport': 'Export Viewport',
+        'export.tabs.workspace': 'Export Workspace',
+        'export.format.label': 'Format',
+        'export.filename.label': 'Filename',
+        'export.filename.placeholder': 'Enter filename',
+        'export.exportButton': 'Export',
+        // Workspace manager
+        'workspace.sharedTooltip': 'Shared workspace',
+        'workspace.rename': 'Rename',
+        'workspace.delete': 'Delete',
+        // Zoom panel
+        'zoom.zoomIn': 'Zoom in',
+        'zoom.zoomOut': 'Zoom out',
+        // Utility panel
+        'utility.undo': 'Undo',
+        'utility.redo': 'Redo',
+        'utility.delete': 'Delete selected items',
+        // Share dialog
+        'share.dialogTitle': 'Share Workspace',
+        'share.linkSharing.label': 'Link sharing',
+        'share.linkSharing.enabledDescription': 'Anyone with the link can access this workspace.',
+        'share.linkSharing.disabledDescription': 'Link sharing is disabled. Only you can access this workspace.',
+        'share.linkSharing.toggleLabel': 'Enable link sharing',
+        'share.copyLink.title': 'Copy link',
+        'share.copyLink.copied': 'Copied!',
+        // Login dialog
+        'login.dialogTitle': 'Sign in',
+        // Current user dialog
+        'currentUser.dialogTitle': 'Account',
+        // Back to content
+        'backToContent.label': 'Back to content',
+        // Tool config
+        'toolConfig.collapse': 'Collapse',
+        'toolConfig.expand': 'Expand',
+        // More menu button
+        'moreMenu.ariaLabel': 'More options',
+        // Engine
+        'engine.loading': 'Loading...',
+        // Watermark
+        'watermark.poweredBy': 'Powered by Kritzel',
+    },
+};
+
+/**
+ * Built-in German locale.
+ */
+const DE_LOCALE = {
+    code: 'de',
+    label: 'Deutsch',
+    terms: {
+        // Context menu
+        'menu.copy': 'Kopieren',
+        'menu.cut': 'Ausschneiden',
+        'menu.paste': 'Einfügen',
+        'menu.selectAll': 'Alles auswählen',
+        'menu.order': 'Anordnen',
+        'menu.bringToFront': 'In den Vordergrund',
+        'menu.sendToBack': 'In den Hintergrund',
+        'menu.moveUp': 'Nach vorne',
+        'menu.moveDown': 'Nach hinten',
+        'menu.align': 'Ausrichten',
+        'menu.alignLeft': 'Linksbündig ausrichten',
+        'menu.alignCenterHorizontal': 'Horizontal zentrieren',
+        'menu.alignRight': 'Rechtsbündig ausrichten',
+        'menu.alignTop': 'Oben ausrichten',
+        'menu.alignCenterVertical': 'Vertikal zentrieren',
+        'menu.alignBottom': 'Unten ausrichten',
+        'menu.group': 'Gruppieren',
+        'menu.ungroup': 'Gruppierung aufheben',
+        'menu.export': 'Exportieren',
+        'menu.exportAsSvg': 'Als SVG exportieren',
+        'menu.exportAsPng': 'Als PNG exportieren',
+        'menu.delete': 'Löschen',
+        // More menu
+        'menu.share': 'Teilen',
+        'menu.import': 'Importieren',
+        'menu.settings': 'Einstellungen',
+        'menu.logout': 'Abmelden',
+        // Settings dialog
+        'settings.dialogTitle': 'Einstellungen',
+        'settings.categories.general': 'Allgemein',
+        'settings.categories.viewport': 'Ansichtsfenster',
+        'settings.categories.shortcuts': 'Tastenkürzel',
+        'settings.categories.developer': 'Entwickleroptionen',
+        'settings.categories.about': 'Über',
+        'settings.general.title': 'Allgemeine Einstellungen',
+        'settings.general.theme.label': 'Design',
+        'settings.general.theme.description': 'Wählen Sie ein registriertes Farbdesign für die Editor-Oberfläche.',
+        'settings.general.language.label': 'Sprache',
+        'settings.general.language.description': 'Wählen Sie die Anzeigesprache für die Editor-Oberfläche.',
+        'settings.general.lockDrawingScale.label': 'Zeichenskalierung sperren',
+        'settings.general.lockDrawingScale.description': 'Wenn aktiviert, behalten gezeichnete Objekte unabhängig von der aktuellen Zoomstufe eine feste visuelle Größe.',
+        'settings.viewport.title': 'Ansichtsfenster-Einstellungen',
+        'settings.viewport.minZoom.label': 'Minimale Zoomstufe',
+        'settings.viewport.minZoom.description': 'Legt die minimale Zoomstufe fest. Niedrigere Werte ermöglichen weiteres Herauszoomen, um mehr von der Zeichenfläche zu sehen.',
+        'settings.viewport.maxZoom.label': 'Maximale Zoomstufe',
+        'settings.viewport.maxZoom.description': 'Legt die maximale Zoomstufe fest. Höhere Werte ermöglichen näheres Heranzoomen für Detailarbeit.',
+        'settings.viewport.boundaryLeft.label': 'Ansichtsfenster-Grenze links',
+        'settings.viewport.boundaryLeft.description': 'Linke Grenze in Weltkoordinaten. Legen Sie fest, wie weit das Ansichtsfenster nach links verschoben werden kann.',
+        'settings.viewport.boundaryRight.label': 'Ansichtsfenster-Grenze rechts',
+        'settings.viewport.boundaryRight.description': 'Rechte Grenze in Weltkoordinaten. Legen Sie fest, wie weit das Ansichtsfenster nach rechts verschoben werden kann.',
+        'settings.viewport.boundaryTop.label': 'Ansichtsfenster-Grenze oben',
+        'settings.viewport.boundaryTop.description': 'Obere Grenze in Weltkoordinaten. Legen Sie fest, wie weit das Ansichtsfenster nach oben verschoben werden kann.',
+        'settings.viewport.boundaryBottom.label': 'Ansichtsfenster-Grenze unten',
+        'settings.viewport.boundaryBottom.description': 'Untere Grenze in Weltkoordinaten. Legen Sie fest, wie weit das Ansichtsfenster nach unten verschoben werden kann.',
+        'settings.viewport.boundaryPlaceholder': 'Unendlich',
+        'settings.shortcuts.title': 'Tastenkürzel',
+        'settings.developer.title': 'Entwickleroptionen',
+        'settings.developer.showViewportInfo.label': 'Ansichtsfenster-Infos anzeigen',
+        'settings.developer.showViewportInfo.description': 'Zeigt Debug-Informationen zum Ansichtsfenster an, z. B. Position, Zoomstufe und Grenzen.',
+        'settings.developer.showObjectInfo.label': 'Objekt-Infos anzeigen',
+        'settings.developer.showObjectInfo.description': 'Zeigt Debug-Informationen zu Objekten auf der Zeichenfläche an.',
+        'settings.developer.showSyncProviderInfo.label': 'Sync-Provider-Infos anzeigen',
+        'settings.developer.showSyncProviderInfo.description': 'Zeigt Debug-Informationen zum Verbindungsstatus des Sync-Providers an.',
+        'settings.developer.showMigrationInfo.label': 'Migrations-Infos anzeigen',
+        'settings.developer.showMigrationInfo.description': 'Zeigt Debug-Informationen zu Datenmigrationen an.',
+        'settings.about.title': 'Über',
+        'settings.about.description': 'Kritzel – Eine Zeichenanwendung',
+        // Export dialog
+        'export.dialogTitle': 'Exportieren',
+        'export.tabs.viewport': 'Ansichtsfenster exportieren',
+        'export.tabs.workspace': 'Arbeitsbereich exportieren',
+        'export.format.label': 'Format',
+        'export.filename.label': 'Dateiname',
+        'export.filename.placeholder': 'Dateiname eingeben',
+        'export.exportButton': 'Exportieren',
+        // Workspace manager
+        'workspace.sharedTooltip': 'Geteilter Arbeitsbereich',
+        'workspace.rename': 'Umbenennen',
+        'workspace.delete': 'Löschen',
+        // Zoom panel
+        'zoom.zoomIn': 'Vergrößern',
+        'zoom.zoomOut': 'Verkleinern',
+        // Utility panel
+        'utility.undo': 'Rückgängig',
+        'utility.redo': 'Wiederholen',
+        'utility.delete': 'Ausgewählte Elemente löschen',
+        // Share dialog
+        'share.dialogTitle': 'Arbeitsbereich teilen',
+        'share.linkSharing.label': 'Link-Freigabe',
+        'share.linkSharing.enabledDescription': 'Jeder mit dem Link kann auf diesen Arbeitsbereich zugreifen.',
+        'share.linkSharing.disabledDescription': 'Die Link-Freigabe ist deaktiviert. Nur Sie können auf diesen Arbeitsbereich zugreifen.',
+        'share.linkSharing.toggleLabel': 'Link-Freigabe aktivieren',
+        'share.copyLink.title': 'Link kopieren',
+        'share.copyLink.copied': 'Kopiert!',
+        // Login dialog
+        'login.dialogTitle': 'Anmelden',
+        // Current user dialog
+        'currentUser.dialogTitle': 'Konto',
+        // Back to content
+        'backToContent.label': 'Zurück zum Inhalt',
+        // Tool config
+        'toolConfig.collapse': 'Einklappen',
+        'toolConfig.expand': 'Ausklappen',
+        // More menu button
+        'moreMenu.ariaLabel': 'Weitere Optionen',
+        // Engine
+        'engine.loading': 'Wird geladen...',
+        // Watermark
+        'watermark.poweredBy': 'Bereitgestellt von Kritzel',
+    },
+};
+
+/**
+ * Built-in French locale.
+ */
+const FR_LOCALE = {
+    code: 'fr',
+    label: 'Français',
+    terms: {
+        // Context menu
+        'menu.copy': 'Copier',
+        'menu.cut': 'Couper',
+        'menu.paste': 'Coller',
+        'menu.selectAll': 'Tout sélectionner',
+        'menu.order': 'Ordre',
+        'menu.bringToFront': 'Mettre au premier plan',
+        'menu.sendToBack': "Mettre à l'arrière-plan",
+        'menu.moveUp': 'Avancer',
+        'menu.moveDown': 'Reculer',
+        'menu.align': 'Aligner',
+        'menu.alignLeft': 'Aligner à gauche',
+        'menu.alignCenterHorizontal': 'Centrer horizontalement',
+        'menu.alignRight': 'Aligner à droite',
+        'menu.alignTop': 'Aligner en haut',
+        'menu.alignCenterVertical': 'Centrer verticalement',
+        'menu.alignBottom': 'Aligner en bas',
+        'menu.group': 'Grouper',
+        'menu.ungroup': 'Dégrouper',
+        'menu.export': 'Exporter',
+        'menu.exportAsSvg': 'Exporter en SVG',
+        'menu.exportAsPng': 'Exporter en PNG',
+        'menu.delete': 'Supprimer',
+        // More menu
+        'menu.share': 'Partager',
+        'menu.import': 'Importer',
+        'menu.settings': 'Paramètres',
+        'menu.logout': 'Déconnexion',
+        // Settings dialog
+        'settings.dialogTitle': 'Paramètres',
+        'settings.categories.general': 'Général',
+        'settings.categories.viewport': "Fenêtre d'affichage",
+        'settings.categories.shortcuts': 'Raccourcis clavier',
+        'settings.categories.developer': 'Options développeur',
+        'settings.categories.about': 'À propos',
+        'settings.general.title': 'Paramètres généraux',
+        'settings.general.theme.label': 'Thème',
+        'settings.general.theme.description': "Sélectionnez un thème de couleurs enregistré pour l'interface de l'éditeur.",
+        'settings.general.language.label': 'Langue',
+        'settings.general.language.description': "Sélectionnez la langue d'affichage de l'interface de l'éditeur.",
+        'settings.general.lockDrawingScale.label': "Verrouiller l'échelle de dessin",
+        'settings.general.lockDrawingScale.description': "Lorsque cette option est activée, les objets dessinés conservent une taille visuelle fixe quel que soit le niveau de zoom actuel.",
+        'settings.viewport.title': "Paramètres de la fenêtre d'affichage",
+        'settings.viewport.minZoom.label': 'Niveau de zoom minimal',
+        'settings.viewport.minZoom.description': 'Définit le niveau de zoom minimal. Des valeurs plus faibles permettent de dézoomer davantage pour voir une plus grande partie du canevas.',
+        'settings.viewport.maxZoom.label': 'Niveau de zoom maximal',
+        'settings.viewport.maxZoom.description': 'Définit le niveau de zoom maximal. Des valeurs plus élevées permettent de zoomer davantage pour un travail détaillé.',
+        'settings.viewport.boundaryLeft.label': "Limite gauche de la fenêtre d'affichage",
+        'settings.viewport.boundaryLeft.description': "Limite gauche en coordonnées du monde. Définissez jusqu'où la fenêtre d'affichage peut se déplacer vers la gauche.",
+        'settings.viewport.boundaryRight.label': "Limite droite de la fenêtre d'affichage",
+        'settings.viewport.boundaryRight.description': "Limite droite en coordonnées du monde. Définissez jusqu'où la fenêtre d'affichage peut se déplacer vers la droite.",
+        'settings.viewport.boundaryTop.label': "Limite supérieure de la fenêtre d'affichage",
+        'settings.viewport.boundaryTop.description': "Limite supérieure en coordonnées du monde. Définissez jusqu'où la fenêtre d'affichage peut se déplacer vers le haut.",
+        'settings.viewport.boundaryBottom.label': "Limite inférieure de la fenêtre d'affichage",
+        'settings.viewport.boundaryBottom.description': "Limite inférieure en coordonnées du monde. Définissez jusqu'où la fenêtre d'affichage peut se déplacer vers le bas.",
+        'settings.viewport.boundaryPlaceholder': 'Infini',
+        'settings.shortcuts.title': 'Raccourcis clavier',
+        'settings.developer.title': 'Options développeur',
+        'settings.developer.showViewportInfo.label': "Afficher les infos de la fenêtre d'affichage",
+        'settings.developer.showViewportInfo.description': "Affiche les informations de débogage de la fenêtre d'affichage telles que la position, le niveau de zoom et les limites.",
+        'settings.developer.showObjectInfo.label': 'Afficher les infos des objets',
+        'settings.developer.showObjectInfo.description': 'Affiche les informations de débogage des objets sur le canevas.',
+        'settings.developer.showSyncProviderInfo.label': 'Afficher les infos du fournisseur de synchronisation',
+        'settings.developer.showSyncProviderInfo.description': "Affiche les informations de débogage sur l'état de connexion du fournisseur de synchronisation.",
+        'settings.developer.showMigrationInfo.label': 'Afficher les infos de migration',
+        'settings.developer.showMigrationInfo.description': 'Affiche les informations de débogage sur les migrations de données.',
+        'settings.about.title': 'À propos',
+        'settings.about.description': 'Kritzel - Une application de dessin',
+        // Export dialog
+        'export.dialogTitle': 'Exporter',
+        'export.tabs.viewport': "Exporter la fenêtre d'affichage",
+        'export.tabs.workspace': "Exporter l'espace de travail",
+        'export.format.label': 'Format',
+        'export.filename.label': 'Nom du fichier',
+        'export.filename.placeholder': 'Saisir le nom du fichier',
+        'export.exportButton': 'Exporter',
+        // Workspace manager
+        'workspace.sharedTooltip': 'Espace de travail partagé',
+        'workspace.rename': 'Renommer',
+        'workspace.delete': 'Supprimer',
+        // Zoom panel
+        'zoom.zoomIn': 'Zoom avant',
+        'zoom.zoomOut': 'Zoom arrière',
+        // Utility panel
+        'utility.undo': 'Annuler',
+        'utility.redo': 'Rétablir',
+        'utility.delete': 'Supprimer les éléments sélectionnés',
+        // Share dialog
+        'share.dialogTitle': "Partager l'espace de travail",
+        'share.linkSharing.label': 'Partage par lien',
+        'share.linkSharing.enabledDescription': 'Toute personne disposant du lien peut accéder à cet espace de travail.',
+        'share.linkSharing.disabledDescription': 'Le partage par lien est désactivé. Vous seul pouvez accéder à cet espace de travail.',
+        'share.linkSharing.toggleLabel': 'Activer le partage par lien',
+        'share.copyLink.title': 'Copier le lien',
+        'share.copyLink.copied': 'Copié !',
+        // Login dialog
+        'login.dialogTitle': 'Se connecter',
+        // Current user dialog
+        'currentUser.dialogTitle': 'Compte',
+        // Back to content
+        'backToContent.label': 'Retour au contenu',
+        // Tool config
+        'toolConfig.collapse': 'Réduire',
+        'toolConfig.expand': 'Développer',
+        // More menu button
+        'moreMenu.ariaLabel': "Plus d'options",
+        // Engine
+        'engine.loading': 'Chargement...',
+        // Watermark
+        'watermark.poweredBy': 'Propulsé par Kritzel',
+    },
+};
+
+/** Key used to store the settings object in localStorage. */
+const SETTINGS_STORAGE_KEY = 'kritzel-settings';
+/** Default locale used when no stored preference exists. */
+const DEFAULT_LOCALE = 'en';
+/**
+ * Manages localization state and term resolution across the Kritzel editor.
+ *
+ * The manager is owned per {@link KritzelCore} instance (like the theme manager)
+ * so that multiple editors on the same page can use different languages in
+ * isolation.
+ *
+ * Term resolution follows a deterministic fallback chain for each key:
+ * 1. active locale's custom terms
+ * 2. active locale's built-in terms
+ * 3. fallback locale's custom terms
+ * 4. fallback locale's built-in terms
+ * 5. the key itself (last resort)
+ *
+ * Persistence of the selected locale is handled by the KritzelSettings
+ * component; this manager only reads the stored value.
+ */
+class KritzelLocalizationManager {
+    _core;
+    _storageKey;
+    /** Built-in locale definitions, keyed by locale code. */
+    _builtinLocales = new Map();
+    /** Consumer-registered locale definitions, keyed by locale code. */
+    _customLocales = new Map();
+    _currentLocale = DEFAULT_LOCALE;
+    _fallbackLocale = DEFAULT_LOCALE;
+    /**
+     * Creates a new KritzelLocalizationManager instance.
+     * Seeds the built-in locales and initializes the current locale from the
+     * settings object in localStorage (or the default locale).
+     *
+     * @param core - The KritzelCore instance this manager belongs to
+     */
+    constructor(core) {
+        this._core = core;
+        this._storageKey = core.editorId ? `${SETTINGS_STORAGE_KEY}-${core.editorId}` : SETTINGS_STORAGE_KEY;
+        this._builtinLocales.set(EN_LOCALE.code, EN_LOCALE);
+        this._builtinLocales.set(DE_LOCALE.code, DE_LOCALE);
+        this._builtinLocales.set(FR_LOCALE.code, FR_LOCALE);
+        this._currentLocale = this.getStoredLocale();
+    }
+    /**
+     * Gets the currently active locale code.
+     */
+    get currentLocale() {
+        return this._currentLocale;
+    }
+    /**
+     * Gets the fallback locale code used when a term is missing from the active locale.
+     */
+    get fallbackLocale() {
+        return this._fallbackLocale;
+    }
+    /**
+     * Sets the fallback locale code used when a term is missing from the active locale.
+     *
+     * @param code - The fallback locale code
+     */
+    setFallbackLocale(code) {
+        this._fallbackLocale = code;
+    }
+    /**
+     * Registers consumer-provided locale definitions. Definitions are merged by
+     * code; registering the same code again replaces the previous definition.
+     * A registered locale may provide a partial set of terms — missing terms are
+     * resolved through the fallback chain.
+     *
+     * @param locales - The locale definitions to register
+     */
+    registerLocales(locales) {
+        for (const locale of locales) {
+            this._customLocales.set(locale.code, locale);
+        }
+    }
+    /**
+     * Sets the active locale and triggers a re-render so UI strings update.
+     *
+     * @param code - The locale code to activate
+     */
+    setLocale(code) {
+        this._currentLocale = code;
+        this._core.rerender();
+    }
+    /**
+     * Gets the list of available locale codes (built-in and registered).
+     */
+    getAvailableLocales() {
+        return Array.from(new Set([...this._builtinLocales.keys(), ...this._customLocales.keys()]));
+    }
+    /**
+     * Gets the available locales as `{ code, label }` pairs for use in a selector.
+     * A registered locale's label takes precedence over the built-in label; the
+     * code is used as the label when none is provided.
+     */
+    getAvailableLocaleOptions() {
+        return this.getAvailableLocales().map(code => ({ code, label: this.getLocaleLabel(code) }));
+    }
+    /**
+     * Gets the display label for a locale code, falling back to the code itself.
+     *
+     * @param code - The locale code
+     */
+    getLocaleLabel(code) {
+        return this._customLocales.get(code)?.label ?? this._builtinLocales.get(code)?.label ?? code;
+    }
+    /**
+     * Resolves a term key to its translated string for the active locale and
+     * interpolates any `{placeholder}` tokens.
+     *
+     * @param key - The term key to resolve
+     * @param vars - Optional values for `{placeholder}` interpolation
+     * @returns The translated, interpolated string (or the key if unresolved)
+     *
+     * @example
+     * manager.translate('menu.copy'); // 'Copy'
+     * manager.translate('share.expires', { date: '5/1' }); // 'Expires 5/1'
+     */
+    translate(key, vars) {
+        const resolved = this._customLocales.get(this._currentLocale)?.terms[key] ??
+            this._builtinLocales.get(this._currentLocale)?.terms[key] ??
+            this._customLocales.get(this._fallbackLocale)?.terms[key] ??
+            this._builtinLocales.get(this._fallbackLocale)?.terms[key] ??
+            key;
+        return LocalizationHelper.interpolate(resolved, vars);
+    }
+    /**
+     * Resolves every known term key for the active locale into a flat map.
+     *
+     * The key set is the union of all keys defined across the built-in and
+     * registered locales, so consumer-added keys are included. Each value is
+     * resolved through the same fallback chain as {@link translate} (without
+     * interpolation, since these are shared, variable-free UI labels).
+     *
+     * @returns A map of every term key to its resolved string for the active locale
+     */
+    getAllTerms() {
+        const keys = new Set();
+        for (const locale of [...this._builtinLocales.values(), ...this._customLocales.values()]) {
+            for (const key of Object.keys(locale.terms)) {
+                keys.add(key);
+            }
+        }
+        const result = {};
+        for (const key of keys) {
+            result[key] = this.translate(key);
+        }
+        return result;
+    }
+    /**
+     * Reads the stored locale from the settings object in localStorage using this
+     * instance's namespaced key.
+     *
+     * @returns The stored locale code if valid, or the default locale
+     */
+    getStoredLocale() {
+        if (typeof localStorage === 'undefined') {
+            return DEFAULT_LOCALE;
+        }
+        const stored = localStorage.getItem(this._storageKey);
+        if (!stored) {
+            return DEFAULT_LOCALE;
+        }
+        try {
+            const parsed = JSON.parse(stored);
+            if (typeof parsed?.locale === 'string') {
+                return parsed.locale;
+            }
+        }
+        catch {
+            // Invalid JSON, use default
+        }
+        return DEFAULT_LOCALE;
+    }
+    /**
+     * Cleans up the localization manager state.
+     * Provided for lifecycle parity with other managers.
+     */
+    cleanup() {
+        this._customLocales.clear();
+    }
+}
+
+/**
+ * License verification constants.
+ *
+ * Kritzel licenses are offline Ed25519 signed tokens. The owner signs each
+ * customer's token with a private key that never leaves their machine
+ * (see scripts/license/); the library verifies tokens against the public key
+ * below. The public key is safe to ship — it can only *verify* signatures,
+ * never forge them.
+ */
+/**
+ * Token format version prefix. A valid license key looks like:
+ *
+ *   KRTZL1.<base64url(payload JSON)>.<base64url(ed25519 signature)>
+ *
+ * Bump the version (and this prefix) if the token scheme ever changes.
+ */
+const KRITZEL_LICENSE_TOKEN_PREFIX = 'KRTZL1.';
+/**
+ * Raw 32-byte Ed25519 public key (base64url) used to verify license tokens.
+ *
+ * Generate the matching key pair with `npm run license:keygen` and paste the
+ * printed public key here. Replacing this value invalidates every license
+ * signed with the previous key.
+ */
+const KRITZEL_LICENSE_PUBLIC_KEY = 'I-pYJlxDEjT94rwSaqhXW5Sv__fMKS-JKKnV3pg0PaM';
+
+/** Minimum delay (ms) between periodic license re-validations. */
+const MIN_REVALIDATION_DELAY_MS = 30_000;
+/** Maximum delay (ms) between periodic license re-validations. */
+const MAX_REVALIDATION_DELAY_MS = 60_000;
+/**
+ * Manages license validation state for the Kritzel editor.
+ *
+ * The manager is owned per {@link KritzelCore} instance (like the theme and
+ * localization managers) so that multiple editors on the same page validate
+ * independently.
+ *
+ * A license key is an offline Ed25519 signed token of the form
+ * `KRTZL1.<base64url(payload)>.<base64url(signature)>`. The library verifies it
+ * against the embedded {@link KRITZEL_LICENSE_PUBLIC_KEY}; only the owner can
+ * mint tokens, with the matching private key (see scripts/license/).
+ *
+ * Responsibilities:
+ * - Cheaply reject absent/malformed/expired keys synchronously so the watermark
+ *   never flashes off for an obviously invalid key.
+ * - Verify the signature asynchronously via WebCrypto, then drive a rerender if
+ *   the licensed state changed so the watermark is re-asserted on the reactive
+ *   render path.
+ * - Periodically re-check on a randomized interval so the check is harder to
+ *   stub out programmatically than a fixed `setInterval`. Re-checks reuse the
+ *   cached verified token and only re-evaluate expiry, so crypto is not re-run
+ *   on an unchanged key every tick.
+ *
+ * Failure semantics (fail open):
+ * - No key provided -> unlicensed (free tier, watermark shown). The normal
+ *   default, not an error.
+ * - Key present but cleanly invalid (malformed, bad signature, expired) ->
+ *   unlicensed.
+ * - Key present but validation throws an *unexpected* internal error, or the
+ *   runtime lacks Ed25519 support in WebCrypto -> fail open and treat as
+ *   licensed so a library defect or old browser never breaks a paying
+ *   customer's app.
+ */
+class KritzelLicenseManager {
+    _core;
+    /** The most recently provided license key, re-checked on each periodic tick. */
+    _licenseKey;
+    /** Cached result of the latest validation. */
+    _isLicensed = false;
+    /**
+     * The token whose signature most recently verified successfully. Lets the
+     * periodic re-check skip crypto and only re-evaluate expiry while the key is
+     * unchanged.
+     */
+    _verifiedToken;
+    /**
+     * Monotonic id incremented on every {@link validate} call. An in-flight async
+     * verification only commits its result if its id still matches, so a stale
+     * verification resolving after a newer call can never clobber fresh state.
+     */
+    _validationId = 0;
+    /** Cached imported public key, lazily created on first signature check. */
+    _publicKeyPromise;
+    /** Handle for the self-rescheduling re-validation timer. */
+    _timer = null;
+    /**
+     * Creates a new KritzelLicenseManager instance.
+     * @param core - The KritzelCore instance this manager belongs to
+     */
+    constructor(core) {
+        this._core = core;
+    }
+    /**
+     * Whether the editor is currently considered licensed (watermark hidden).
+     */
+    get isLicensed() {
+        return this._isLicensed;
+    }
+    /**
+     * Validates the given license key.
+     *
+     * Runs a synchronous structural pre-check first: an absent, malformed, or
+     * already-expired key resolves the state immediately (no async work). A
+     * structurally valid key then has its signature verified asynchronously; the
+     * licensed state is committed (and a rerender triggered) only if it changed.
+     *
+     * The return value reflects the state known *synchronously* at call time. The
+     * authoritative result for a structurally valid key arrives shortly after via
+     * the async verification and the reactive rerender.
+     *
+     * @param key - The license key to validate, or undefined to clear the license
+     * @returns The licensed state known synchronously at call time
+     */
+    validate(key) {
+        this._licenseKey = key;
+        const validationId = ++this._validationId;
+        let pre;
+        try {
+            pre = this.preCheck(key);
+        }
+        catch {
+            // Fail open: an unexpected internal error in the cheap pre-check must
+            // never break a paying customer's app.
+            this.commit(true, validationId);
+            return this._isLicensed;
+        }
+        if (pre.status === 'rejected') {
+            this._verifiedToken = undefined;
+            this.commit(false, validationId);
+            return this._isLicensed;
+        }
+        // Structurally valid and unexpired. If we already verified this exact token,
+        // the signature is still good, so license it without re-running crypto.
+        if (this._verifiedToken === key) {
+            this.commit(true, validationId);
+            return this._isLicensed;
+        }
+        // Otherwise verify the signature asynchronously. Leave the current state
+        // untouched until it settles so a forged token cannot even briefly hide the
+        // watermark (default state is unlicensed), and a valid renewal does not flap.
+        this.verifySignature(pre.payloadSegment, pre.signatureSegment)
+            .then(valid => {
+            if (validationId !== this._validationId) {
+                return; // A newer validate() superseded this one.
+            }
+            if (valid) {
+                this._verifiedToken = key;
+                this.commit(true, validationId);
+            }
+            else {
+                this._verifiedToken = undefined;
+                this.commit(false, validationId);
+            }
+        })
+            .catch(() => {
+            if (validationId !== this._validationId) {
+                return;
+            }
+            // Fail open on unexpected crypto errors / missing Ed25519 support.
+            this.commit(true, validationId);
+        });
+        return this._isLicensed;
+    }
+    /**
+     * Starts periodic re-validation on a randomized interval between
+     * {@link MIN_REVALIDATION_DELAY_MS} and {@link MAX_REVALIDATION_DELAY_MS}.
+     *
+     * Uses a self-rescheduling `setTimeout` (a fresh random delay each cycle)
+     * rather than a fixed `setInterval`, making the check fractionally harder to
+     * predict and no-op programmatically. Any existing timer is cleared first so
+     * the method is idempotent.
+     */
+    startPeriodicValidation() {
+        this.stopPeriodicValidation();
+        this.scheduleNextValidation();
+    }
+    /**
+     * Stops periodic re-validation and releases the timer.
+     */
+    stopPeriodicValidation() {
+        if (this._timer !== null) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+    }
+    /**
+     * Cleanup hook called when the editor is torn down.
+     */
+    destroy() {
+        this.stopPeriodicValidation();
+    }
+    /**
+     * Commits a new licensed state, triggering a rerender only when it changed.
+     * The {@link validationId} guard is checked by async callers; synchronous
+     * callers pass the current id.
+     */
+    commit(nextLicensed, validationId) {
+        if (validationId !== this._validationId) {
+            return;
+        }
+        if (nextLicensed !== this._isLicensed) {
+            this._isLicensed = nextLicensed;
+            this._core.rerender();
+        }
+    }
+    /**
+     * Schedules the next re-validation tick at a randomized delay.
+     */
+    scheduleNextValidation() {
+        const delay = this.getRandomRevalidationDelay();
+        this._timer = setTimeout(() => {
+            this.validate(this._licenseKey);
+            this.scheduleNextValidation();
+        }, delay);
+    }
+    /**
+     * Returns a random delay within the configured re-validation window.
+     */
+    getRandomRevalidationDelay() {
+        const span = MAX_REVALIDATION_DELAY_MS - MIN_REVALIDATION_DELAY_MS;
+        return MIN_REVALIDATION_DELAY_MS + Math.floor(Math.random() * (span + 1));
+    }
+    /**
+     * Synchronous structural pre-check of a license key: verifies the format
+     * prefix, three-part structure, JSON payload, and (if present) that the token
+     * has not expired. Does not verify the signature.
+     *
+     * @returns `rejected` for absent/malformed/expired keys, or `pass` with the
+     *   parsed segments and claims for a structurally valid, unexpired token.
+     */
+    preCheck(key) {
+        if (key === undefined || key === null) {
+            return { status: 'rejected' };
+        }
+        const token = key.trim();
+        if (token.length === 0 || !token.startsWith(KRITZEL_LICENSE_TOKEN_PREFIX)) {
+            return { status: 'rejected' };
+        }
+        const body = token.slice(KRITZEL_LICENSE_TOKEN_PREFIX.length);
+        const parts = body.split('.');
+        if (parts.length !== 2 || parts[0].length === 0 || parts[1].length === 0) {
+            return { status: 'rejected' };
+        }
+        const [payloadSegment, signatureSegment] = parts;
+        let claims;
+        try {
+            claims = JSON.parse(this.base64UrlToString(payloadSegment));
+        }
+        catch {
+            return { status: 'rejected' };
+        }
+        if (claims === null || typeof claims !== 'object') {
+            return { status: 'rejected' };
+        }
+        if (typeof claims.exp === 'number' && claims.exp * 1000 <= Date.now()) {
+            return { status: 'rejected' }; // Cleanly expired.
+        }
+        return { status: 'pass', payloadSegment, signatureSegment, claims };
+    }
+    /**
+     * Verifies the Ed25519 signature of the token against the embedded public
+     * key. Resolves true/false for a definitive valid/invalid signature.
+     *
+     * Rejects (rather than resolving false) on unexpected crypto failures or when
+     * the runtime lacks Ed25519 support, so the caller fails open.
+     */
+    async verifySignature(payloadSegment, signatureSegment) {
+        const publicKey = await this.getPublicKey();
+        const data = this.utf8Bytes(payloadSegment);
+        const signature = this.base64UrlToBytes(signatureSegment);
+        return crypto.subtle.verify('Ed25519', publicKey, signature, data);
+    }
+    /**
+     * Imports and caches the embedded Ed25519 public key for signature checks.
+     */
+    getPublicKey() {
+        if (!this._publicKeyPromise) {
+            const raw = this.base64UrlToBytes(KRITZEL_LICENSE_PUBLIC_KEY);
+            this._publicKeyPromise = Promise.resolve().then(() => crypto.subtle.importKey('raw', raw, { name: 'Ed25519' }, false, ['verify']));
+            // If import fails (e.g. no Ed25519 support), drop the cache so a later
+            // tick can retry, and let the rejection propagate to fail open.
+            this._publicKeyPromise.catch(() => {
+                this._publicKeyPromise = undefined;
+            });
+        }
+        return this._publicKeyPromise;
+    }
+    /** Decodes a base64url string to its UTF-8 text. */
+    base64UrlToString(value) {
+        return new TextDecoder().decode(this.base64UrlToBytes(value));
+    }
+    /** Decodes a base64url string to raw bytes. */
+    base64UrlToBytes(value) {
+        const base64 = value.replace(/-/g, '+').replace(/_/g, '/');
+        const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), '=');
+        const binary = atob(padded);
+        const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+    }
+    /** Encodes a string to its UTF-8 bytes. */
+    utf8Bytes(value) {
+        const encoded = new TextEncoder().encode(value);
+        const bytes = new Uint8Array(new ArrayBuffer(encoded.length));
+        bytes.set(encoded);
+        return bytes;
+    }
+}
+
 const DEFAULT_BRUSH_CONFIG = {
     type: 'pen',
     color: DEFAULT_COLOR_PALETTE[0],
@@ -28495,6 +29486,9 @@ exports.DEFAULT_COLOR_PALETTE = DEFAULT_COLOR_PALETTE;
 exports.DEFAULT_LINE_TOOL_CONFIG = DEFAULT_LINE_TOOL_CONFIG;
 exports.DEFAULT_STROKE_SIZES = DEFAULT_STROKE_SIZES;
 exports.DEFAULT_TEXT_CONFIG = DEFAULT_TEXT_CONFIG;
+exports.DE_LOCALE = DE_LOCALE;
+exports.EN_LOCALE = EN_LOCALE;
+exports.FR_LOCALE = FR_LOCALE;
 exports.HocuspocusProvider = HocuspocusProvider;
 exports.HocuspocusProviderWebsocket = HocuspocusProviderWebsocket;
 exports.IndexedDBAssetProvider = IndexedDBAssetProvider;
@@ -28502,6 +29496,7 @@ exports.KritzelAnchorManager = KritzelAnchorManager;
 exports.KritzelAssetResolver = KritzelAssetResolver;
 exports.KritzelBaseHandler = KritzelBaseHandler;
 exports.KritzelBaseObject = KritzelBaseObject;
+exports.KritzelBaseTool = KritzelBaseTool;
 exports.KritzelBrushTool = KritzelBrushTool;
 exports.KritzelClassHelper = KritzelClassHelper;
 exports.KritzelColorHelper = KritzelColorHelper;
@@ -28514,8 +29509,11 @@ exports.KritzelIconRegistry = KritzelIconRegistry;
 exports.KritzelImage = KritzelImage;
 exports.KritzelImageTool = KritzelImageTool;
 exports.KritzelKeyboardHelper = KritzelKeyboardHelper;
+exports.KritzelLicenseManager = KritzelLicenseManager;
 exports.KritzelLine = KritzelLine;
 exports.KritzelLineTool = KritzelLineTool;
+exports.KritzelLocalizationManager = KritzelLocalizationManager;
+exports.KritzelMathHelper = KritzelMathHelper;
 exports.KritzelPath = KritzelPath;
 exports.KritzelSelectionBox = KritzelSelectionBox;
 exports.KritzelSelectionGroup = KritzelSelectionGroup;