apple-notes-mcp 2.9.7 → 2.9.8

package/build/index.js

@@ -417,11 +417,11 @@ var require_codegen = __commonJS({
         const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
         return `${varKind} ${this.name}${rhs};` + _n;
       }
-      optimizeNames(names, constants6) {
+      optimizeNames(names, constants7) {
         if (!names[this.name.str])
           return;
         if (this.rhs)
-          this.rhs = optimizeExpr(this.rhs, names, constants6);
+          this.rhs = optimizeExpr(this.rhs, names, constants7);
         return this;
       }
       get names() {
@@ -438,10 +438,10 @@ var require_codegen = __commonJS({
       render({ _n }) {
         return `${this.lhs} = ${this.rhs};` + _n;
       }
-      optimizeNames(names, constants6) {
+      optimizeNames(names, constants7) {
         if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
           return;
-        this.rhs = optimizeExpr(this.rhs, names, constants6);
+        this.rhs = optimizeExpr(this.rhs, names, constants7);
         return this;
       }
       get names() {
@@ -502,8 +502,8 @@ var require_codegen = __commonJS({
       optimizeNodes() {
         return `${this.code}` ? this : void 0;
       }
-      optimizeNames(names, constants6) {
-        this.code = optimizeExpr(this.code, names, constants6);
+      optimizeNames(names, constants7) {
+        this.code = optimizeExpr(this.code, names, constants7);
         return this;
       }
       get names() {
@@ -532,12 +532,12 @@ var require_codegen = __commonJS({
         }
         return nodes.length > 0 ? this : void 0;
       }
-      optimizeNames(names, constants6) {
+      optimizeNames(names, constants7) {
         const { nodes } = this;
         let i = nodes.length;
         while (i--) {
           const n = nodes[i];
-          if (n.optimizeNames(names, constants6))
+          if (n.optimizeNames(names, constants7))
             continue;
           subtractNames(names, n.names);
           nodes.splice(i, 1);
@@ -590,12 +590,12 @@ var require_codegen = __commonJS({
           return void 0;
         return this;
       }
-      optimizeNames(names, constants6) {
+      optimizeNames(names, constants7) {
         var _a;
-        this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants6);
-        if (!(super.optimizeNames(names, constants6) || this.else))
+        this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants7);
+        if (!(super.optimizeNames(names, constants7) || this.else))
           return;
-        this.condition = optimizeExpr(this.condition, names, constants6);
+        this.condition = optimizeExpr(this.condition, names, constants7);
         return this;
       }
       get names() {
@@ -618,10 +618,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.iteration})` + super.render(opts);
       }
-      optimizeNames(names, constants6) {
-        if (!super.optimizeNames(names, constants6))
+      optimizeNames(names, constants7) {
+        if (!super.optimizeNames(names, constants7))
           return;
-        this.iteration = optimizeExpr(this.iteration, names, constants6);
+        this.iteration = optimizeExpr(this.iteration, names, constants7);
         return this;
       }
       get names() {
@@ -657,10 +657,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
       }
-      optimizeNames(names, constants6) {
-        if (!super.optimizeNames(names, constants6))
+      optimizeNames(names, constants7) {
+        if (!super.optimizeNames(names, constants7))
           return;
-        this.iterable = optimizeExpr(this.iterable, names, constants6);
+        this.iterable = optimizeExpr(this.iterable, names, constants7);
         return this;
       }
       get names() {
@@ -702,11 +702,11 @@ var require_codegen = __commonJS({
         (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
         return this;
       }
-      optimizeNames(names, constants6) {
+      optimizeNames(names, constants7) {
         var _a, _b;
-        super.optimizeNames(names, constants6);
-        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants6);
-        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants6);
+        super.optimizeNames(names, constants7);
+        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants7);
+        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants7);
         return this;
       }
       get names() {
@@ -1007,7 +1007,7 @@ var require_codegen = __commonJS({
     function addExprNames(names, from) {
       return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
     }
-    function optimizeExpr(expr, names, constants6) {
+    function optimizeExpr(expr, names, constants7) {
       if (expr instanceof code_1.Name)
         return replaceName(expr);
       if (!canOptimize(expr))
@@ -1022,14 +1022,14 @@ var require_codegen = __commonJS({
         return items;
       }, []));
       function replaceName(n) {
-        const c = constants6[n.str];
+        const c = constants7[n.str];
         if (c === void 0 || names[n.str] !== 1)
           return n;
         delete names[n.str];
         return c;
       }
       function canOptimize(e) {
-        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants6[c.str] !== void 0);
+        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants7[c.str] !== void 0);
       }
     }
     function subtractNames(names, from) {
@@ -3558,14 +3558,14 @@ var require_utils = __commonJS({
       }
       return output;
     }
-    function recomposeAuthority(component) {
+    function recomposeAuthority(component2) {
       const uriTokens = [];
-      if (component.userinfo !== void 0) {
-        uriTokens.push(encodeUserinfo(component.userinfo));
+      if (component2.userinfo !== void 0) {
+        uriTokens.push(encodeUserinfo(component2.userinfo));
         uriTokens.push("@");
       }
-      if (component.host !== void 0) {
-        let host = component.host;
+      if (component2.host !== void 0) {
+        let host = component2.host;
         if (!isIPv4(host)) {
           let ipV6res = normalizeIPv6(host);
           if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
@@ -3580,9 +3580,9 @@ var require_utils = __commonJS({
         }
         uriTokens.push(host);
       }
-      if (typeof component.port === "number" || typeof component.port === "string") {
+      if (typeof component2.port === "number" || typeof component2.port === "string") {
         uriTokens.push(":");
-        uriTokens.push(String(component.port));
+        uriTokens.push(String(component2.port));
       }
       return uriTokens.length ? uriTokens.join("") : void 0;
     }
@@ -3641,21 +3641,21 @@ var require_schemes = __commonJS({
         return false;
       }
     }
-    function httpParse(component) {
-      if (!component.host) {
-        component.error = component.error || "HTTP URIs must have a host.";
+    function httpParse(component2) {
+      if (!component2.host) {
+        component2.error = component2.error || "HTTP URIs must have a host.";
       }
-      return component;
+      return component2;
     }
-    function httpSerialize(component) {
-      const secure = String(component.scheme).toLowerCase() === "https";
-      if (component.port === (secure ? 443 : 80) || component.port === "") {
-        component.port = void 0;
+    function httpSerialize(component2) {
+      const secure = String(component2.scheme).toLowerCase() === "https";
+      if (component2.port === (secure ? 443 : 80) || component2.port === "") {
+        component2.port = void 0;
       }
-      if (!component.path) {
-        component.path = "/";
+      if (!component2.path) {
+        component2.path = "/";
       }
-      return component;
+      return component2;
     }
     function wsParse(wsComponent) {
       wsComponent.secure = wsIsSecure(wsComponent);
@@ -3935,7 +3935,7 @@ var require_fast_uri = __commonJS({
       return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
     }
     function serialize(cmpts, opts) {
-      const component = {
+      const component2 = {
         host: cmpts.host,
         scheme: cmpts.scheme,
         userinfo: cmpts.userinfo,
@@ -3953,36 +3953,36 @@ var require_fast_uri = __commonJS({
       };
       const options = Object.assign({}, opts);
       const uriTokens = [];
-      if (component.scheme) {
-        component.scheme = decodeValidScheme(component.scheme);
-      }
-      const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
-      if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
-      const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
-      const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
-      if (component.path !== void 0) {
+      if (component2.scheme) {
+        component2.scheme = decodeValidScheme(component2.scheme);
+      }
+      const schemeHandler = getSchemeHandler(options.scheme || component2.scheme);
+      if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component2, options);
+      const hasAuthority = component2.userinfo !== void 0 || component2.host !== void 0 || component2.port !== void 0;
+      const pathNoScheme = !options.skipEscape && component2.scheme === void 0 && !hasAuthority;
+      if (component2.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = serializePathEncoding(component.path, pathNoScheme);
+          component2.path = serializePathEncoding(component2.path, pathNoScheme);
         } else {
-          component.path = normalizePercentEncoding(component.path);
+          component2.path = normalizePercentEncoding(component2.path);
         }
       }
-      if (options.reference !== "suffix" && component.scheme) {
-        component.scheme = decodeValidScheme(component.scheme);
-        uriTokens.push(component.scheme, ":");
+      if (options.reference !== "suffix" && component2.scheme) {
+        component2.scheme = decodeValidScheme(component2.scheme);
+        uriTokens.push(component2.scheme, ":");
       }
-      const authority = recomposeAuthority(component);
+      const authority = recomposeAuthority(component2);
       if (authority !== void 0) {
         if (options.reference !== "suffix") {
           uriTokens.push("//");
         }
         uriTokens.push(authority);
-        if (component.path && component.path[0] !== "/") {
+        if (component2.path && component2.path[0] !== "/") {
           uriTokens.push("/");
         }
       }
-      if (component.path !== void 0) {
-        let s = component.path;
+      if (component2.path !== void 0) {
+        let s = component2.path;
         if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
           s = removeDotSegments(s);
         }
@@ -3994,11 +3994,11 @@ var require_fast_uri = __commonJS({
         }
         uriTokens.push(s);
       }
-      if (component.query !== void 0) {
-        uriTokens.push("?", encodeQuery(component.query));
+      if (component2.query !== void 0) {
+        uriTokens.push("?", encodeQuery(component2.query));
       }
-      if (component.fragment !== void 0) {
-        uriTokens.push("#", encodeFragment(component.fragment));
+      if (component2.fragment !== void 0) {
+        uriTokens.push("#", encodeFragment(component2.fragment));
       }
       return uriTokens.join("");
     }
@@ -4014,14 +4014,14 @@ var require_fast_uri = __commonJS({
       }
       return void 0;
     }
-    function hasMalformedPercentEncoding(component) {
-      if (component === void 0) return false;
-      let percent = component.indexOf("%");
+    function hasMalformedPercentEncoding(component2) {
+      if (component2 === void 0) return false;
+      let percent = component2.indexOf("%");
       while (percent !== -1) {
-        if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+        if (percent + 2 >= component2.length || !/^[\da-f]{2}$/iu.test(component2.slice(percent + 1, percent + 3))) {
           return true;
         }
-        percent = component.indexOf("%", percent + 3);
+        percent = component2.indexOf("%", percent + 3);
       }
       return false;
     }
@@ -7422,7 +7422,7 @@ var require_DOMException = __commonJS({
       "INVALID_NODE_TYPE_ERR (24): the supplied node is invalid or has an invalid ancestor for this operation",
       "DATA_CLONE_ERR (25): the object can not be cloned."
     ];
-    var constants6 = {
+    var constants7 = {
       INDEX_SIZE_ERR,
       DOMSTRING_SIZE_ERR: 2,
       // historical
@@ -7461,8 +7461,8 @@ var require_DOMException = __commonJS({
       this.name = names[code];
     }
     DOMException.prototype.__proto__ = Error.prototype;
-    for (c in constants6) {
-      v = { value: constants6[c] };
+    for (c in constants7) {
+      v = { value: constants7[c] };
       Object.defineProperty(DOMException, c, v);
       Object.defineProperty(DOMException.prototype, c, v);
     }
@@ -8859,23 +8859,23 @@ var require_attributes = __commonJS({
   "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/attributes.js"(exports) {
     "use strict";
     var utils = require_utils2();
-    exports.property = function(attr) {
-      if (Array.isArray(attr.type)) {
+    exports.property = function(attr2) {
+      if (Array.isArray(attr2.type)) {
         var valid = /* @__PURE__ */ Object.create(null);
-        attr.type.forEach(function(val) {
+        attr2.type.forEach(function(val) {
           valid[val.value || val] = val.alias || val;
         });
-        var missingValueDefault = attr.missing;
+        var missingValueDefault = attr2.missing;
         if (missingValueDefault === void 0) {
           missingValueDefault = null;
         }
-        var invalidValueDefault = attr.invalid;
+        var invalidValueDefault = attr2.invalid;
         if (invalidValueDefault === void 0) {
           invalidValueDefault = missingValueDefault;
         }
         return {
           get: function() {
-            var v = this._getattr(attr.name);
+            var v = this._getattr(attr2.name);
             if (v === null) return missingValueDefault;
             v = valid[v.toLowerCase()];
             if (v !== void 0) return v;
@@ -8883,38 +8883,38 @@ var require_attributes = __commonJS({
             return v;
           },
           set: function(v) {
-            this._setattr(attr.name, v);
+            this._setattr(attr2.name, v);
           }
         };
-      } else if (attr.type === Boolean) {
+      } else if (attr2.type === Boolean) {
         return {
           get: function() {
-            return this.hasAttribute(attr.name);
+            return this.hasAttribute(attr2.name);
           },
           set: function(v) {
             if (v) {
-              this._setattr(attr.name, "");
+              this._setattr(attr2.name, "");
             } else {
-              this.removeAttribute(attr.name);
+              this.removeAttribute(attr2.name);
             }
           }
         };
-      } else if (attr.type === Number || attr.type === "long" || attr.type === "unsigned long" || attr.type === "limited unsigned long with fallback") {
-        return numberPropDesc(attr);
-      } else if (!attr.type || attr.type === String) {
+      } else if (attr2.type === Number || attr2.type === "long" || attr2.type === "unsigned long" || attr2.type === "limited unsigned long with fallback") {
+        return numberPropDesc(attr2);
+      } else if (!attr2.type || attr2.type === String) {
         return {
           get: function() {
-            return this._getattr(attr.name) || "";
+            return this._getattr(attr2.name) || "";
           },
           set: function(v) {
-            if (attr.treatNullAsEmptyString && v === null) {
+            if (attr2.treatNullAsEmptyString && v === null) {
               v = "";
             }
-            this._setattr(attr.name, v);
+            this._setattr(attr2.name, v);
           }
         };
-      } else if (typeof attr.type === "function") {
-        return attr.type(attr.name, attr);
+      } else if (typeof attr2.type === "function") {
+        return attr2.type(attr2.name, attr2);
       }
       throw new Error("Invalid attribute definition");
     };
@@ -9382,23 +9382,23 @@ var require_select = __commonJS({
       "attr": function(key, op, val, i) {
         op = operators[op];
         return function(el) {
-          var attr;
+          var attr2;
           switch (key) {
             case "for":
-              attr = el.htmlFor;
+              attr2 = el.htmlFor;
               break;
             case "class":
-              attr = el.className;
-              if (attr === "" && el.getAttribute("class") == null) {
-                attr = null;
+              attr2 = el.className;
+              if (attr2 === "" && el.getAttribute("class") == null) {
+                attr2 = null;
               }
               break;
             case "href":
             case "src":
-              attr = el.getAttribute(key, 2);
+              attr2 = el.getAttribute(key, 2);
               break;
             case "title":
-              attr = el.getAttribute("title") || null;
+              attr2 = el.getAttribute("title") || null;
               break;
             // careful with attributes with special getter functions
             case "id":
@@ -9409,7 +9409,7 @@ var require_select = __commonJS({
             case "tabIndex":
             case "style":
               if (el.getAttribute) {
-                attr = el.getAttribute(key);
+                attr2 = el.getAttribute(key);
                 break;
               }
             /* falls through */
@@ -9417,16 +9417,16 @@ var require_select = __commonJS({
               if (el.hasAttribute && !el.hasAttribute(key)) {
                 break;
               }
-              attr = el[key] != null ? el[key] : el.getAttribute && el.getAttribute(key);
+              attr2 = el[key] != null ? el[key] : el.getAttribute && el.getAttribute(key);
               break;
           }
-          if (attr == null) return;
-          attr = attr + "";
+          if (attr2 == null) return;
+          attr2 = attr2 + "";
           if (i) {
-            attr = attr.toLowerCase();
+            attr2 = attr2.toLowerCase();
             val = val.toLowerCase();
           }
-          return op(attr, val);
+          return op(attr2, val);
         };
       },
       ":first-child": function(el) {
@@ -9554,8 +9554,8 @@ var require_select = __commonJS({
         var param = +el + 1;
         return function(el2) {
           if (!el2.href) return;
-          var url = window2.location + "", href = el2 + "";
-          return truncateUrl(url, param) === truncateUrl(href, param);
+          var url = window2.location + "", href2 = el2 + "";
+          return truncateUrl(url, param) === truncateUrl(href2, param);
         };
       },
       ":default": function(el) {
@@ -9581,9 +9581,9 @@ var require_select = __commonJS({
       },
       ":read-only": function(el) {
         if (el.readOnly) return true;
-        var attr = el.getAttribute("contenteditable"), prop = el.contentEditable, name = el.nodeName.toLowerCase();
+        var attr2 = el.getAttribute("contenteditable"), prop = el.contentEditable, name = el.nodeName.toLowerCase();
         name = name !== "input" && name !== "textarea";
-        return (name || el.disabled) && attr == null && prop !== "true";
+        return (name || el.disabled) && attr2 == null && prop !== "true";
       },
       ":read-write": function(el) {
         return !selectors[":read-only"](el);
@@ -9638,38 +9638,38 @@ var require_select = __commonJS({
       "-": function() {
         return true;
       },
-      "=": function(attr, val) {
-        return attr === val;
+      "=": function(attr2, val) {
+        return attr2 === val;
       },
-      "*=": function(attr, val) {
-        return attr.indexOf(val) !== -1;
+      "*=": function(attr2, val) {
+        return attr2.indexOf(val) !== -1;
       },
-      "~=": function(attr, val) {
+      "~=": function(attr2, val) {
         var i, s, f, l;
         for (s = 0; true; s = i + 1) {
-          i = attr.indexOf(val, s);
+          i = attr2.indexOf(val, s);
           if (i === -1) return false;
-          f = attr[i - 1];
-          l = attr[i + val.length];
+          f = attr2[i - 1];
+          l = attr2[i + val.length];
           if ((!f || f === " ") && (!l || l === " ")) return true;
         }
       },
-      "|=": function(attr, val) {
-        var i = attr.indexOf(val), l;
+      "|=": function(attr2, val) {
+        var i = attr2.indexOf(val), l;
         if (i !== 0) return;
-        l = attr[i + val.length];
+        l = attr2[i + val.length];
         return l === "-" || !l;
       },
-      "^=": function(attr, val) {
-        return attr.indexOf(val) === 0;
+      "^=": function(attr2, val) {
+        return attr2.indexOf(val) === 0;
       },
-      "$=": function(attr, val) {
-        var i = attr.lastIndexOf(val);
-        return i !== -1 && i + val.length === attr.length;
+      "$=": function(attr2, val) {
+        var i = attr2.lastIndexOf(val);
+        return i !== -1 && i + val.length === attr2.length;
       },
       // non-standard
-      "!=": function(attr, val) {
-        return attr !== val;
+      "!=": function(attr2, val) {
+        return attr2 !== val;
       }
     };
     var combinators = {
@@ -9721,9 +9721,9 @@ var require_select = __commonJS({
         }
         ref.combinator = function(el) {
           if (!node || !node.getAttribute) return;
-          var attr = node.getAttribute(name) || "";
-          if (attr[0] === "#") attr = attr.substring(1);
-          if (attr === el.id && test(node)) {
+          var attr2 = node.getAttribute(name) || "";
+          if (attr2[0] === "#") attr2 = attr2.substring(1);
+          if (attr2 === el.id && test(node)) {
             return node;
           }
         };
@@ -10107,18 +10107,18 @@ var require_NamedNodeMap = __commonJS({
       setNamedItem: { value: utils.nyi },
       setNamedItemNS: { value: utils.nyi },
       removeNamedItem: { value: function removeNamedItem(qualifiedName) {
-        var attr = this.element.getAttributeNode(qualifiedName);
-        if (attr) {
+        var attr2 = this.element.getAttributeNode(qualifiedName);
+        if (attr2) {
           this.element.removeAttribute(qualifiedName);
-          return attr;
+          return attr2;
         }
         utils.NotFoundError();
       } },
       removeNamedItemNS: { value: function removeNamedItemNS(ns, lname) {
-        var attr = this.element.getAttributeNodeNS(ns, lname);
-        if (attr) {
+        var attr2 = this.element.getAttributeNodeNS(ns, lname);
+        if (attr2) {
           this.element.removeAttributeNS(ns, lname);
-          return attr;
+          return attr2;
         }
         utils.NotFoundError();
       } }
@@ -10558,28 +10558,28 @@ var require_Element = __commonJS({
        *
        */
       getAttribute: { value: function getAttribute(qname) {
-        var attr = this.getAttributeNode(qname);
-        return attr ? attr.value : null;
+        var attr2 = this.getAttributeNode(qname);
+        return attr2 ? attr2.value : null;
       } },
       getAttributeNS: { value: function getAttributeNS(ns, lname) {
-        var attr = this.getAttributeNodeNS(ns, lname);
-        return attr ? attr.value : null;
+        var attr2 = this.getAttributeNodeNS(ns, lname);
+        return attr2 ? attr2.value : null;
       } },
       getAttributeNode: { value: function getAttributeNode(qname) {
         qname = String(qname);
         if (/[A-Z]/.test(qname) && this.isHTML)
           qname = utils.toASCIILowerCase(qname);
-        var attr = this._attrsByQName[qname];
-        if (!attr) return null;
-        if (Array.isArray(attr))
-          attr = attr[0];
-        return attr;
+        var attr2 = this._attrsByQName[qname];
+        if (!attr2) return null;
+        if (Array.isArray(attr2))
+          attr2 = attr2[0];
+        return attr2;
       } },
       getAttributeNodeNS: { value: function getAttributeNodeNS(ns, lname) {
         ns = ns === void 0 || ns === null ? "" : String(ns);
         lname = String(lname);
-        var attr = this._attrsByLName[ns + "|" + lname];
-        return attr ? attr : null;
+        var attr2 = this._attrsByLName[ns + "|" + lname];
+        return attr2 ? attr2 : null;
       } },
       hasAttribute: { value: function hasAttribute(qname) {
         qname = String(qname);
@@ -10618,16 +10618,16 @@ var require_Element = __commonJS({
       } },
       // Set the attribute without error checking. The parser uses this.
       _setAttribute: { value: function _setAttribute(qname, value) {
-        var attr = this._attrsByQName[qname];
+        var attr2 = this._attrsByQName[qname];
         var isnew;
-        if (!attr) {
-          attr = this._newattr(qname);
+        if (!attr2) {
+          attr2 = this._newattr(qname);
           isnew = true;
         } else {
-          if (Array.isArray(attr)) attr = attr[0];
+          if (Array.isArray(attr2)) attr2 = attr2[0];
         }
-        attr.value = value;
-        if (this._attributes) this._attributes[qname] = attr;
+        attr2.value = value;
+        if (this._attributes) this._attributes[qname] = attr2;
         if (isnew && this._newattrhook) this._newattrhook(qname, value);
       } },
       // Check for errors, and then set the attribute
@@ -10650,25 +10650,25 @@ var require_Element = __commonJS({
         }
         if (ns === "" || ns === void 0) ns = null;
         var key = (ns === null ? "" : ns) + "|" + lname;
-        var attr = this._attrsByLName[key];
+        var attr2 = this._attrsByLName[key];
         var isnew;
-        if (!attr) {
-          attr = new Attr(this, lname, prefix, ns);
+        if (!attr2) {
+          attr2 = new Attr(this, lname, prefix, ns);
           isnew = true;
-          this._attrsByLName[key] = attr;
+          this._attrsByLName[key] = attr2;
           if (this._attributes) {
-            this._attributes[this._attrKeys.length] = attr;
+            this._attributes[this._attrKeys.length] = attr2;
           }
           this._attrKeys.push(key);
-          this._addQName(attr);
+          this._addQName(attr2);
         } else if (false) {
-          if (attr.prefix !== prefix) {
-            this._removeQName(attr);
-            attr.prefix = prefix;
-            this._addQName(attr);
+          if (attr2.prefix !== prefix) {
+            this._removeQName(attr2);
+            attr2.prefix = prefix;
+            this._addQName(attr2);
           }
         }
-        attr.value = value;
+        attr2.value = value;
         if (isnew && this._newattrhook) this._newattrhook(qname, value);
       } },
       // Do error checking then call _setAttributeNS
@@ -10682,21 +10682,21 @@ var require_Element = __commonJS({
           utils.NamespaceError();
         this._setAttributeNS(ns, qname, String(value));
       } },
-      setAttributeNode: { value: function setAttributeNode(attr) {
-        if (attr.ownerElement !== null && attr.ownerElement !== this) {
+      setAttributeNode: { value: function setAttributeNode(attr2) {
+        if (attr2.ownerElement !== null && attr2.ownerElement !== this) {
           throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR);
         }
         var result = null;
-        var oldAttrs = this._attrsByQName[attr.name];
+        var oldAttrs = this._attrsByQName[attr2.name];
         if (oldAttrs) {
           if (!Array.isArray(oldAttrs)) {
             oldAttrs = [oldAttrs];
           }
           if (oldAttrs.some(function(a) {
-            return a === attr;
+            return a === attr2;
           })) {
-            return attr;
-          } else if (attr.ownerElement !== null) {
+            return attr2;
+          } else if (attr2.ownerElement !== null) {
             throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR);
           }
           oldAttrs.forEach(function(a) {
@@ -10704,47 +10704,47 @@ var require_Element = __commonJS({
           }, this);
           result = oldAttrs[0];
         }
-        this.setAttributeNodeNS(attr);
+        this.setAttributeNodeNS(attr2);
         return result;
       } },
-      setAttributeNodeNS: { value: function setAttributeNodeNS(attr) {
-        if (attr.ownerElement !== null) {
+      setAttributeNodeNS: { value: function setAttributeNodeNS(attr2) {
+        if (attr2.ownerElement !== null) {
           throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR);
         }
-        var ns = attr.namespaceURI;
-        var key = (ns === null ? "" : ns) + "|" + attr.localName;
+        var ns = attr2.namespaceURI;
+        var key = (ns === null ? "" : ns) + "|" + attr2.localName;
         var oldAttr = this._attrsByLName[key];
         if (oldAttr) {
           this.removeAttributeNode(oldAttr);
         }
-        attr._setOwnerElement(this);
-        this._attrsByLName[key] = attr;
+        attr2._setOwnerElement(this);
+        this._attrsByLName[key] = attr2;
         if (this._attributes) {
-          this._attributes[this._attrKeys.length] = attr;
+          this._attributes[this._attrKeys.length] = attr2;
         }
         this._attrKeys.push(key);
-        this._addQName(attr);
-        if (this._newattrhook) this._newattrhook(attr.name, attr.value);
+        this._addQName(attr2);
+        if (this._newattrhook) this._newattrhook(attr2.name, attr2.value);
         return oldAttr || null;
       } },
       removeAttribute: { value: function removeAttribute(qname) {
         qname = String(qname);
         if (/[A-Z]/.test(qname) && this.isHTML)
           qname = utils.toASCIILowerCase(qname);
-        var attr = this._attrsByQName[qname];
-        if (!attr) return;
-        if (Array.isArray(attr)) {
-          if (attr.length > 2) {
-            attr = attr.shift();
+        var attr2 = this._attrsByQName[qname];
+        if (!attr2) return;
+        if (Array.isArray(attr2)) {
+          if (attr2.length > 2) {
+            attr2 = attr2.shift();
           } else {
-            this._attrsByQName[qname] = attr[1];
-            attr = attr[0];
+            this._attrsByQName[qname] = attr2[1];
+            attr2 = attr2[0];
           }
         } else {
           this._attrsByQName[qname] = void 0;
         }
-        var ns = attr.namespaceURI;
-        var key = (ns === null ? "" : ns) + "|" + attr.localName;
+        var ns = attr2.namespaceURI;
+        var key = (ns === null ? "" : ns) + "|" + attr2.localName;
         this._attrsByLName[key] = void 0;
         var i = this._attrKeys.indexOf(key);
         if (this._attributes) {
@@ -10752,41 +10752,41 @@ var require_Element = __commonJS({
           this._attributes[qname] = void 0;
         }
         this._attrKeys.splice(i, 1);
-        var onchange = attr.onchange;
-        attr._setOwnerElement(null);
+        var onchange = attr2.onchange;
+        attr2._setOwnerElement(null);
         if (onchange) {
-          onchange.call(attr, this, attr.localName, attr.value, null);
+          onchange.call(attr2, this, attr2.localName, attr2.value, null);
         }
-        if (this.rooted) this.ownerDocument.mutateRemoveAttr(attr);
+        if (this.rooted) this.ownerDocument.mutateRemoveAttr(attr2);
       } },
       removeAttributeNS: { value: function removeAttributeNS(ns, lname) {
         ns = ns === void 0 || ns === null ? "" : String(ns);
         lname = String(lname);
         var key = ns + "|" + lname;
-        var attr = this._attrsByLName[key];
-        if (!attr) return;
+        var attr2 = this._attrsByLName[key];
+        if (!attr2) return;
         this._attrsByLName[key] = void 0;
         var i = this._attrKeys.indexOf(key);
         if (this._attributes) {
           Array.prototype.splice.call(this._attributes, i, 1);
         }
         this._attrKeys.splice(i, 1);
-        this._removeQName(attr);
-        var onchange = attr.onchange;
-        attr._setOwnerElement(null);
+        this._removeQName(attr2);
+        var onchange = attr2.onchange;
+        attr2._setOwnerElement(null);
         if (onchange) {
-          onchange.call(attr, this, attr.localName, attr.value, null);
+          onchange.call(attr2, this, attr2.localName, attr2.value, null);
         }
-        if (this.rooted) this.ownerDocument.mutateRemoveAttr(attr);
+        if (this.rooted) this.ownerDocument.mutateRemoveAttr(attr2);
       } },
-      removeAttributeNode: { value: function removeAttributeNode(attr) {
-        var ns = attr.namespaceURI;
-        var key = (ns === null ? "" : ns) + "|" + attr.localName;
-        if (this._attrsByLName[key] !== attr) {
+      removeAttributeNode: { value: function removeAttributeNode(attr2) {
+        var ns = attr2.namespaceURI;
+        var key = (ns === null ? "" : ns) + "|" + attr2.localName;
+        if (this._attrsByLName[key] !== attr2) {
           utils.NotFoundError();
         }
-        this.removeAttributeNS(ns, attr.localName);
-        return attr;
+        this.removeAttributeNS(ns, attr2.localName);
+        return attr2;
       } },
       getAttributeNames: { value: function getAttributeNames() {
         var elt = this;
@@ -10798,57 +10798,57 @@ var require_Element = __commonJS({
       // of reflected attributes. It skips some error checking and
       // namespace steps
       _getattr: { value: function _getattr(qname) {
-        var attr = this._attrsByQName[qname];
-        return attr ? attr.value : null;
+        var attr2 = this._attrsByQName[qname];
+        return attr2 ? attr2.value : null;
       } },
       // The raw version of setAttribute for reflected idl attributes.
       _setattr: { value: function _setattr(qname, value) {
-        var attr = this._attrsByQName[qname];
+        var attr2 = this._attrsByQName[qname];
         var isnew;
-        if (!attr) {
-          attr = this._newattr(qname);
+        if (!attr2) {
+          attr2 = this._newattr(qname);
           isnew = true;
         }
-        attr.value = String(value);
-        if (this._attributes) this._attributes[qname] = attr;
+        attr2.value = String(value);
+        if (this._attributes) this._attributes[qname] = attr2;
         if (isnew && this._newattrhook) this._newattrhook(qname, value);
       } },
       // Create a new Attr object, insert it, and return it.
       // Used by setAttribute() and by set()
       _newattr: { value: function _newattr(qname) {
-        var attr = new Attr(this, qname, null, null);
+        var attr2 = new Attr(this, qname, null, null);
         var key = "|" + qname;
-        this._attrsByQName[qname] = attr;
-        this._attrsByLName[key] = attr;
+        this._attrsByQName[qname] = attr2;
+        this._attrsByLName[key] = attr2;
         if (this._attributes) {
-          this._attributes[this._attrKeys.length] = attr;
+          this._attributes[this._attrKeys.length] = attr2;
         }
         this._attrKeys.push(key);
-        return attr;
+        return attr2;
       } },
       // Add a qname->Attr mapping to the _attrsByQName object, taking into
       // account that there may be more than one attr object with the
       // same qname
-      _addQName: { value: function(attr) {
-        var qname = attr.name;
+      _addQName: { value: function(attr2) {
+        var qname = attr2.name;
         var existing = this._attrsByQName[qname];
         if (!existing) {
-          this._attrsByQName[qname] = attr;
+          this._attrsByQName[qname] = attr2;
         } else if (Array.isArray(existing)) {
-          existing.push(attr);
+          existing.push(attr2);
         } else {
-          this._attrsByQName[qname] = [existing, attr];
+          this._attrsByQName[qname] = [existing, attr2];
         }
-        if (this._attributes) this._attributes[qname] = attr;
+        if (this._attributes) this._attributes[qname] = attr2;
       } },
       // Remove a qname->Attr mapping to the _attrsByQName object, taking into
       // account that there may be more than one attr object with the
       // same qname
-      _removeQName: { value: function(attr) {
-        var qname = attr.name;
+      _removeQName: { value: function(attr2) {
+        var qname = attr2.name;
         var target = this._attrsByQName[qname];
         if (Array.isArray(target)) {
-          var idx = target.indexOf(attr);
+          var idx = target.indexOf(attr2);
           utils.assert(idx !== -1);
           if (target.length === 2) {
             this._attrsByQName[qname] = target[1 - idx];
@@ -10857,12 +10857,12 @@ var require_Element = __commonJS({
             }
           } else {
             target.splice(idx, 1);
-            if (this._attributes && this._attributes[qname] === attr) {
+            if (this._attributes && this._attributes[qname] === attr2) {
               this._attributes[qname] = target[0];
             }
           }
         } else {
-          utils.assert(target === attr);
+          utils.assert(target === attr2);
           this._attrsByQName[qname] = void 0;
           if (this._attributes) {
             this._attributes[qname] = void 0;
@@ -12814,10 +12814,10 @@ var require_defineElement = __commonJS({
         var props = spec.props || {};
         if (spec.attributes) {
           for (var n in spec.attributes) {
-            var attr = spec.attributes[n];
-            if (typeof attr !== "object" || Array.isArray(attr)) attr = { type: attr };
-            if (!attr.name) attr.name = n.toLowerCase();
-            props[n] = attributes.property(attr);
+            var attr2 = spec.attributes[n];
+            if (typeof attr2 !== "object" || Array.isArray(attr2)) attr2 = { type: attr2 };
+            if (!attr2.name) attr2.name = n.toLowerCase();
+            props[n] = attributes.property(attr2);
           }
         }
         props.constructor = { value: c, writable: isApiWritable };
@@ -12885,10 +12885,10 @@ var require_htmlelts = __commonJS({
     function define(spec) {
       return defineElement(spec, HTMLElement, htmlElements, htmlNameToImpl);
     }
-    function URL2(attr) {
+    function URL2(attr2) {
       return {
         get: function() {
-          var v = this._getattr(attr);
+          var v = this._getattr(attr2);
           if (v === null) {
             return "";
           }
@@ -12896,14 +12896,14 @@ var require_htmlelts = __commonJS({
           return url === null ? v : url;
         },
         set: function(value) {
-          this._setattr(attr, value);
+          this._setattr(attr2, value);
         }
       };
     }
-    function CORS(attr) {
+    function CORS(attr2) {
       return {
         get: function() {
-          var v = this._getattr(attr);
+          var v = this._getattr(attr2);
           if (v === null) {
             return null;
           }
@@ -12914,9 +12914,9 @@ var require_htmlelts = __commonJS({
         },
         set: function(value) {
           if (value === null || value === void 0) {
-            this.removeAttribute(attr);
+            this.removeAttribute(attr2);
           } else {
-            this._setattr(attr, value);
+            this._setattr(attr2, value);
           }
         }
       };
@@ -15050,22 +15050,22 @@ var require_Document = __commonJS({
       // Invoked when an attribute's value changes. Attr holds the new
       // value.  oldval is the old value.  Attribute mutations can also
       // involve changes to the prefix (and therefore the qualified name)
-      mutateAttr: { value: function(attr, oldval) {
+      mutateAttr: { value: function(attr2, oldval) {
         if (this.mutationHandler) {
           this.mutationHandler({
             type: MUTATE.ATTR,
-            target: attr.ownerElement,
-            attr
+            target: attr2.ownerElement,
+            attr: attr2
           });
         }
       } },
       // Used by removeAttribute and removeAttributeNS for attributes.
-      mutateRemoveAttr: { value: function(attr) {
+      mutateRemoveAttr: { value: function(attr2) {
         if (this.mutationHandler) {
           this.mutationHandler({
             type: MUTATE.REMOVE_ATTR,
-            target: attr.ownerElement,
-            attr
+            target: attr2.ownerElement,
+            attr: attr2
           });
         }
       } },
@@ -15131,8 +15131,8 @@ var require_Document = __commonJS({
           this.byId[id2] = void 0;
         }
       } },
-      _resolve: { value: function(href) {
-        return new URL2(this._documentBaseURL).resolve(href);
+      _resolve: { value: function(href2) {
+        return new URL2(this._documentBaseURL).resolve(href2);
       } },
       _documentBaseURL: { get: function() {
         var url = this._address;
@@ -15367,7 +15367,7 @@ var require_HTMLParser = __commonJS({
     var impl = html.elements;
     var pushAll = Function.prototype.apply.bind(Array.prototype.push);
     var EOF = -1;
-    var TEXT = 1;
+    var TEXT2 = 1;
     var TAG = 2;
     var ENDTAG = 3;
     var COMMENT = 4;
@@ -18636,7 +18636,7 @@ var require_HTMLParser = __commonJS({
             if (s[0] === "\n") s = s.substring(1);
             if (s.length === 0) return;
           }
-          insertToken(TEXT, s);
+          insertToken(TEXT2, s);
           textIncludesNUL = false;
         }
         ignore_linefeed = false;
@@ -18671,7 +18671,7 @@ var require_HTMLParser = __commonJS({
           if (s[0] === "\n") s = s.substring(1);
           if (s.length === 0) return;
         }
-        insertToken(TEXT, s);
+        insertToken(TEXT2, s);
       }
       function emitTag() {
         if (is_end_tag) insertToken(ENDTAG, tagnamebuf);
@@ -18727,10 +18727,10 @@ var require_HTMLParser = __commonJS({
         if (!current || current.namespaceURI === NAMESPACE.HTML) {
           parser(t, value, arg3, arg4);
         } else {
-          if (t !== TAG && t !== TEXT) {
+          if (t !== TAG && t !== TEXT2) {
             insertForeignToken(t, value, arg3, arg4);
           } else {
-            if (isMathmlTextIntegrationPoint(current) && (t === TEXT || t === TAG && value !== "mglyph" && value !== "malignmark") || t === TAG && value === "svg" && current.namespaceURI === NAMESPACE.MATHML && current.localName === "annotation-xml" || isHTMLIntegrationPoint(current)) {
+            if (isMathmlTextIntegrationPoint(current) && (t === TEXT2 || t === TAG && value !== "mglyph" && value !== "malignmark") || t === TAG && value === "svg" && current.namespaceURI === NAMESPACE.MATHML && current.localName === "annotation-xml" || isHTMLIntegrationPoint(current)) {
               text_integration_mode = true;
               parser(t, value, arg3, arg4);
               text_integration_mode = false;
@@ -18809,11 +18809,11 @@ var require_HTMLParser = __commonJS({
           var elt = doc2._createElementNS(name, ns, null);
           if (attrs) {
             for (var i = 0, n = attrs.length; i < n; i++) {
-              var attr = attrs[i];
-              if (attr.length === 2)
-                elt._setAttribute(attr[0], attr[1]);
+              var attr2 = attrs[i];
+              if (attr2.length === 2)
+                elt._setAttribute(attr2[0], attr2[1]);
               else {
-                elt._setAttributeNS(attr[2], attr[0], attr[1]);
+                elt._setAttributeNS(attr2[2], attr2[0], attr2[1]);
               }
             }
           }
@@ -22695,7 +22695,7 @@ var require_HTMLParser = __commonJS({
         foster_parent_mode = false;
       }
       function in_table_text_mode(t, value, arg3, arg4) {
-        if (t === TEXT) {
+        if (t === TEXT2) {
           if (textIncludesNUL) {
             value = value.replace(NULCHARS, "");
             if (value.length === 0) return;
@@ -22706,7 +22706,7 @@ var require_HTMLParser = __commonJS({
           pending_table_text.length = 0;
           if (NONWS.test(s)) {
             foster_parent_mode = true;
-            in_body_mode(TEXT, s);
+            in_body_mode(TEXT2, s);
             foster_parent_mode = false;
           } else {
             insertText(s);
@@ -23602,9 +23602,9 @@ var require_Location = __commonJS({
     var URL2 = require_URL();
     var URLUtils = require_URLUtils();
     module.exports = Location;
-    function Location(window2, href) {
+    function Location(window2, href2) {
       this._window = window2;
-      this._href = href;
+      this._href = href2;
     }
     Location.prototype = Object.create(URLUtils.prototype, {
       constructor: { value: Location },
@@ -24011,10 +24011,10 @@ var require_turndown_cjs = __commonJS({
         return options.linkStyle === "inlined" && node.nodeName === "A" && node.getAttribute("href");
       },
       replacement: function(content, node) {
-        var href = escapeLinkDestination(node.getAttribute("href"));
+        var href2 = escapeLinkDestination(node.getAttribute("href"));
         var title = escapeLinkTitle(cleanAttribute(node.getAttribute("title")));
         var titlePart = title ? ' "' + title + '"' : "";
-        return "[" + content + "](" + href + titlePart + ")";
+        return "[" + content + "](" + href2 + titlePart + ")";
       }
     };
     rules.referenceLink = {
@@ -24022,7 +24022,7 @@ var require_turndown_cjs = __commonJS({
         return options.linkStyle === "referenced" && node.nodeName === "A" && node.getAttribute("href");
       },
       replacement: function(content, node, options) {
-        var href = escapeLinkDestination(node.getAttribute("href"));
+        var href2 = escapeLinkDestination(node.getAttribute("href"));
         var title = cleanAttribute(node.getAttribute("title"));
         if (title) title = ' "' + escapeLinkTitle(title) + '"';
         var replacement;
@@ -24030,16 +24030,16 @@ var require_turndown_cjs = __commonJS({
         switch (options.linkReferenceStyle) {
           case "collapsed":
             replacement = "[" + content + "][]";
-            reference = "[" + content + "]: " + href + title;
+            reference = "[" + content + "]: " + href2 + title;
             break;
           case "shortcut":
             replacement = "[" + content + "]";
-            reference = "[" + content + "]: " + href + title;
+            reference = "[" + content + "]: " + href2 + title;
             break;
           default:
             var id2 = this.references.length + 1;
             replacement = "[" + content + "][" + id2 + "]";
-            reference = "[" + id2 + "]: " + href + title;
+            reference = "[" + id2 + "]: " + href2 + title;
         }
         this.references.push(reference);
         return replacement;
@@ -29878,7 +29878,7 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
     try {
       const orig = payload.value;
       const url = new URL(orig);
-      const href = url.href;
+      const href2 = url.href;
       if (def.hostname) {
         def.hostname.lastIndex = 0;
         if (!def.hostname.test(url.hostname)) {
@@ -29907,10 +29907,10 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
           });
         }
       }
-      if (!orig.endsWith("/") && href.endsWith("/")) {
-        payload.value = href.slice(0, -1);
+      if (!orig.endsWith("/") && href2.endsWith("/")) {
+        payload.value = href2.slice(0, -1);
       } else {
-        payload.value = href;
+        payload.value = href2;
       }
       return;
     } catch (_) {
@@ -41076,9 +41076,9 @@ function fileSize(p) {
 function makeTempDir() {
   return mkdtempSync(resolve(tmpdir(), "apple-notes-att-"));
 }
-function readAllowedTextFile(p, maxBytes, roots = allowedSaveRoots()) {
-  if (!p || !p.trim()) throw new Error("A content file path is required.");
-  if (!isAbsolute(p)) throw new Error(`Content file path must be absolute: "${p}"`);
+function assertReadableInRoots(p, roots = allowedSaveRoots(), label = "Content file") {
+  if (!p || !p.trim()) throw new Error(`A ${label.toLowerCase()} path is required.`);
+  if (!isAbsolute(p)) throw new Error(`${label} path must be absolute: "${p}"`);
   const abs = resolve(p);
   if (!isWithinRoots(abs, roots))
     throw new Error(`Refusing to read outside allowed locations (home, temp, /Volumes): "${abs}"`);
@@ -41086,12 +41086,16 @@ function readAllowedTextFile(p, maxBytes, roots = allowedSaveRoots()) {
   try {
     canonical = canonicalize(abs);
   } catch {
-    throw new Error(`Content file does not exist or cannot be resolved: "${abs}"`);
+    throw new Error(`${label} does not exist or cannot be resolved: "${abs}"`);
   }
   if (!isWithinRoots(canonical, canonicalRoots(roots)))
     throw new Error(
       `Refusing to read outside allowed locations (home, temp, /Volumes): "${abs}" resolves to "${canonical}".`
     );
+  return abs;
+}
+function readAllowedTextFile(p, maxBytes, roots = allowedSaveRoots()) {
+  const abs = assertReadableInRoots(p, roots);
   let descriptor;
   try {
     descriptor = openSync(abs, constants.O_RDONLY | constants.O_NOFOLLOW);
@@ -48488,6 +48492,13 @@ var FEATURES = [
     minimumMacOSVersion: null,
     requirements: [{ kind: "native_write_helper" }]
   },
+  {
+    name: "svgAnalysis",
+    description: "Analyze a local SVG file for conversion into editable strokes: classification, required losses, and a digest",
+    tools: ["analyze-svg"],
+    minimumMacOSVersion: null,
+    requirements: []
+  },
   {
     name: "paragraphLinks",
     description: "Link to a specific paragraph or heading inside a note",
@@ -51906,6 +51917,2071 @@ function registerFolderDelete(server2, manager, deps = defaultDeps) {
   );
 }
 
+// src/utils/svgAnalyzer.ts
+import { createHash as createHash4 } from "node:crypto";
+import { closeSync as closeSync6, constants as constants6, fstatSync as fstatSync6, openSync as openSync6, readSync as readSync4 } from "node:fs";
+
+// src/utils/svgColor.ts
+var NAMED = {
+  aliceblue: "f0f8ff",
+  antiquewhite: "faebd7",
+  aqua: "00ffff",
+  aquamarine: "7fffd4",
+  azure: "f0ffff",
+  beige: "f5f5dc",
+  bisque: "ffe4c4",
+  black: "000000",
+  blanchedalmond: "ffebcd",
+  blue: "0000ff",
+  blueviolet: "8a2be2",
+  brown: "a52a2a",
+  burlywood: "deb887",
+  cadetblue: "5f9ea0",
+  chartreuse: "7fff00",
+  chocolate: "d2691e",
+  coral: "ff7f50",
+  cornflowerblue: "6495ed",
+  cornsilk: "fff8dc",
+  crimson: "dc143c",
+  cyan: "00ffff",
+  darkblue: "00008b",
+  darkcyan: "008b8b",
+  darkgoldenrod: "b8860b",
+  darkgray: "a9a9a9",
+  darkgreen: "006400",
+  darkgrey: "a9a9a9",
+  darkkhaki: "bdb76b",
+  darkmagenta: "8b008b",
+  darkolivegreen: "556b2f",
+  darkorange: "ff8c00",
+  darkorchid: "9932cc",
+  darkred: "8b0000",
+  darksalmon: "e9967a",
+  darkseagreen: "8fbc8f",
+  darkslateblue: "483d8b",
+  darkslategray: "2f4f4f",
+  darkslategrey: "2f4f4f",
+  darkturquoise: "00ced1",
+  darkviolet: "9400d3",
+  deeppink: "ff1493",
+  deepskyblue: "00bfff",
+  dimgray: "696969",
+  dimgrey: "696969",
+  dodgerblue: "1e90ff",
+  firebrick: "b22222",
+  floralwhite: "fffaf0",
+  forestgreen: "228b22",
+  fuchsia: "ff00ff",
+  gainsboro: "dcdcdc",
+  ghostwhite: "f8f8ff",
+  gold: "ffd700",
+  goldenrod: "daa520",
+  gray: "808080",
+  green: "008000",
+  greenyellow: "adff2f",
+  grey: "808080",
+  honeydew: "f0fff0",
+  hotpink: "ff69b4",
+  indianred: "cd5c5c",
+  indigo: "4b0082",
+  ivory: "fffff0",
+  khaki: "f0e68c",
+  lavender: "e6e6fa",
+  lavenderblush: "fff0f5",
+  lawngreen: "7cfc00",
+  lemonchiffon: "fffacd",
+  lightblue: "add8e6",
+  lightcoral: "f08080",
+  lightcyan: "e0ffff",
+  lightgoldenrodyellow: "fafad2",
+  lightgray: "d3d3d3",
+  lightgreen: "90ee90",
+  lightgrey: "d3d3d3",
+  lightpink: "ffb6c1",
+  lightsalmon: "ffa07a",
+  lightseagreen: "20b2aa",
+  lightskyblue: "87cefa",
+  lightslategray: "778899",
+  lightslategrey: "778899",
+  lightsteelblue: "b0c4de",
+  lightyellow: "ffffe0",
+  lime: "00ff00",
+  limegreen: "32cd32",
+  linen: "faf0e6",
+  magenta: "ff00ff",
+  maroon: "800000",
+  mediumaquamarine: "66cdaa",
+  mediumblue: "0000cd",
+  mediumorchid: "ba55d3",
+  mediumpurple: "9370db",
+  mediumseagreen: "3cb371",
+  mediumslateblue: "7b68ee",
+  mediumspringgreen: "00fa9a",
+  mediumturquoise: "48d1cc",
+  mediumvioletred: "c71585",
+  midnightblue: "191970",
+  mintcream: "f5fffa",
+  mistyrose: "ffe4e1",
+  moccasin: "ffe4b5",
+  navajowhite: "ffdead",
+  navy: "000080",
+  oldlace: "fdf5e6",
+  olive: "808000",
+  olivedrab: "6b8e23",
+  orange: "ffa500",
+  orangered: "ff4500",
+  orchid: "da70d6",
+  palegoldenrod: "eee8aa",
+  palegreen: "98fb98",
+  paleturquoise: "afeeee",
+  palevioletred: "db7093",
+  papayawhip: "ffefd5",
+  peachpuff: "ffdab9",
+  peru: "cd853f",
+  pink: "ffc0cb",
+  plum: "dda0dd",
+  powderblue: "b0e0e6",
+  purple: "800080",
+  rebeccapurple: "663399",
+  red: "ff0000",
+  rosybrown: "bc8f8f",
+  royalblue: "4169e1",
+  saddlebrown: "8b4513",
+  salmon: "fa8072",
+  sandybrown: "f4a460",
+  seagreen: "2e8b57",
+  seashell: "fff5ee",
+  sienna: "a0522d",
+  silver: "c0c0c0",
+  skyblue: "87ceeb",
+  slateblue: "6a5acd",
+  slategray: "708090",
+  slategrey: "708090",
+  snow: "fffafa",
+  springgreen: "00ff7f",
+  steelblue: "4682b4",
+  tan: "d2b48c",
+  teal: "008080",
+  thistle: "d8bfd8",
+  tomato: "ff6347",
+  turquoise: "40e0d0",
+  violet: "ee82ee",
+  wheat: "f5deb3",
+  white: "ffffff",
+  whitesmoke: "f5f5f5",
+  yellow: "ffff00",
+  yellowgreen: "9acd32"
+};
+var clamp01 = (v) => Math.min(1, Math.max(0, v));
+function hexToRgba(hex3) {
+  if (!/^[0-9a-f]+$/i.test(hex3)) return null;
+  const expand = hex3.length <= 4 ? [...hex3].map((c) => c + c).join("") : hex3;
+  if (expand.length !== 6 && expand.length !== 8) return null;
+  const byte = (i) => Number.parseInt(expand.slice(i, i + 2), 16) / 255;
+  return [byte(0), byte(2), byte(4), expand.length === 8 ? byte(6) : 1];
+}
+function component(text2, scale) {
+  const m = /^([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)(%?)$/i.exec(text2.trim());
+  if (!m) return null;
+  const n = Number(m[1]);
+  return m[2] ? n / 100 * scale : n;
+}
+function hslToRgb(h, s, l) {
+  const hue = (h % 360 + 360) % 360 / 360;
+  const f = (n) => {
+    const k = (n + hue * 12) % 12;
+    return l - s * Math.min(l, 1 - l) * Math.max(-1, Math.min(k - 3, 9 - k, 1));
+  };
+  return [f(0), f(8), f(4)];
+}
+function functional(name, args) {
+  if (args.length !== 3 && args.length !== 4) return null;
+  const alpha = args.length === 4 ? component(args[3], 1) : 1;
+  if (alpha === null) return null;
+  if (name === "rgb" || name === "rgba") {
+    const channels = args.slice(0, 3).map((a) => component(a, 255));
+    if (channels.some((c) => c === null)) return null;
+    const [r2, g2, b2] = channels.map((c) => clamp01(c / 255));
+    return [r2, g2, b2, clamp01(alpha)];
+  }
+  const h = component(args[0].replace(/deg$/i, ""), 360);
+  const s = component(args[1], 1);
+  const l = component(args[2], 1);
+  if (h === null || s === null || l === null || !args[1].includes("%") || !args[2].includes("%"))
+    return null;
+  const [r, g, b] = hslToRgb(h, clamp01(s), clamp01(l));
+  return [r, g, b, clamp01(alpha)];
+}
+function parseColor(value) {
+  const v = value.trim().toLowerCase();
+  if (v === "transparent") return [0, 0, 0, 0];
+  if (v.startsWith("#")) return hexToRgba(v.slice(1));
+  if (v in NAMED) return hexToRgba(NAMED[v]);
+  const fn = /^(rgba?|hsla?)\(\s*(.*?)\s*\)$/.exec(v);
+  if (!fn) return null;
+  const body = fn[2];
+  const args = body.includes(",") ? body.split(",").map((a) => a.trim()) : body.replace(/\s*\/\s*/, " ").split(/\s+/).filter(Boolean);
+  if (args.some((a) => !a)) return null;
+  return functional(fn[1], args);
+}
+function parsePaint(value) {
+  const v = value.trim();
+  if (v === "none") return { kind: "none" };
+  if (/^currentcolor$/i.test(v)) return { kind: "current" };
+  const url = /^url\(\s*['"]?([^'")]*)['"]?\s*\)/i.exec(v);
+  if (url) return { kind: "url", target: url[1].trim() };
+  const rgba = parseColor(v);
+  return rgba ? { kind: "color", rgba } : { kind: "invalid" };
+}
+
+// src/utils/svgGeometry.ts
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+function multiply(left, right) {
+  const [a, b, c, d, e, f] = left;
+  const [A, B, C, D, E, F] = right;
+  return [
+    a * A + c * B,
+    b * A + d * B,
+    a * C + c * D,
+    b * C + d * D,
+    a * E + c * F + e,
+    b * E + d * F + f
+  ];
+}
+function apply(m, p) {
+  return [m[0] * p[0] + m[2] * p[1] + m[4], m[1] * p[0] + m[3] * p[1] + m[5]];
+}
+function scales(m) {
+  const [a, b, c, d] = m;
+  const s1 = a * a + b * b + c * c + d * d;
+  const det = a * d - b * c;
+  const root = Math.sqrt(Math.max(0, s1 * s1 - 4 * det * det));
+  return [Math.sqrt((s1 + root) / 2), Math.sqrt(Math.max(0, (s1 - root) / 2))];
+}
+var NUMBER = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/y;
+var NumberScanner = class {
+  constructor(text2) {
+    this.text = text2;
+  }
+  text;
+  pos = 0;
+  /** A comma was consumed since the last token (one comma separates two tokens). */
+  comma = true;
+  skip() {
+    while (this.pos < this.text.length) {
+      const ch = this.text[this.pos];
+      if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f") this.pos++;
+      else if (ch === "," && !this.comma) {
+        this.pos++;
+        this.comma = true;
+      } else break;
+    }
+  }
+  done() {
+    this.skip();
+    return this.pos >= this.text.length;
+  }
+  /** The next character, after separators, without consuming it. */
+  peek() {
+    this.skip();
+    return this.text[this.pos] ?? "";
+  }
+  take() {
+    this.skip();
+    this.comma = false;
+    return this.text[this.pos++] ?? "";
+  }
+  number() {
+    this.skip();
+    NUMBER.lastIndex = this.pos;
+    const m = NUMBER.exec(this.text);
+    if (!m) return null;
+    this.pos += m[0].length;
+    this.comma = false;
+    const n = Number(m[0]);
+    return Number.isFinite(n) ? n : null;
+  }
+  flag() {
+    this.skip();
+    const ch = this.text[this.pos];
+    if (ch !== "0" && ch !== "1") return null;
+    this.pos++;
+    this.comma = false;
+    return ch === "1" ? 1 : 0;
+  }
+};
+function parseNumberList(text2) {
+  const scanner = new NumberScanner(text2);
+  const out = [];
+  while (!scanner.done()) {
+    const n = scanner.number();
+    if (n === null) return null;
+    out.push(n);
+  }
+  return out;
+}
+function parseTransform(text2) {
+  let m = IDENTITY;
+  const re = /\s*,?\s*([a-zA-Z]+)\s*\(([^)]*)\)/y;
+  let pos = 0;
+  const trimmed = text2.trim();
+  while (pos < trimmed.length) {
+    re.lastIndex = pos;
+    const hit = re.exec(trimmed);
+    if (!hit) return null;
+    pos = re.lastIndex;
+    const args = parseNumberList(hit[2]);
+    if (!args) return null;
+    const n = args.length;
+    let t;
+    switch (hit[1]) {
+      case "matrix":
+        if (n !== 6) return null;
+        t = args;
+        break;
+      case "translate":
+        if (n !== 1 && n !== 2) return null;
+        t = [1, 0, 0, 1, args[0], args[1] ?? 0];
+        break;
+      case "scale":
+        if (n !== 1 && n !== 2) return null;
+        t = [args[0], 0, 0, args[1] ?? args[0], 0, 0];
+        break;
+      case "rotate": {
+        if (n !== 1 && n !== 3) return null;
+        const r = args[0] * Math.PI / 180;
+        const [cos, sin] = [Math.cos(r), Math.sin(r)];
+        t = [cos, sin, -sin, cos, 0, 0];
+        if (n === 3)
+          t = multiply(multiply([1, 0, 0, 1, args[1], args[2]], t), [
+            1,
+            0,
+            0,
+            1,
+            -args[1],
+            -args[2]
+          ]);
+        break;
+      }
+      case "skewX":
+        if (n !== 1) return null;
+        t = [1, 0, Math.tan(args[0] * Math.PI / 180), 1, 0, 0];
+        break;
+      case "skewY":
+        if (n !== 1) return null;
+        t = [1, Math.tan(args[0] * Math.PI / 180), 0, 1, 0, 0];
+        break;
+      default:
+        return null;
+    }
+    m = multiply(m, t);
+  }
+  return m.every(Number.isFinite) ? m : null;
+}
+var KAPPA = 0.5522847498307936;
+function arcToCubics(from, rxIn, ryIn, angleDeg, largeArc, sweep, to) {
+  if (from[0] === to[0] && from[1] === to[1]) return [];
+  let rx = Math.abs(rxIn);
+  let ry = Math.abs(ryIn);
+  if (rx === 0 || ry === 0) return [{ kind: "L", to }];
+  const phi = angleDeg * Math.PI / 180;
+  const cos = Math.cos(phi);
+  const sin = Math.sin(phi);
+  const dx = (from[0] - to[0]) / 2;
+  const dy = (from[1] - to[1]) / 2;
+  const x1 = cos * dx + sin * dy;
+  const y1 = -sin * dx + cos * dy;
+  const lambda = x1 * x1 / (rx * rx) + y1 * y1 / (ry * ry);
+  if (lambda > 1) {
+    rx *= Math.sqrt(lambda);
+    ry *= Math.sqrt(lambda);
+  }
+  const num2 = rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1;
+  const den = rx * rx * y1 * y1 + ry * ry * x1 * x1;
+  const coef = (largeArc === sweep ? -1 : 1) * Math.sqrt(Math.max(0, num2 / den));
+  const cx1 = coef * rx * y1 / ry;
+  const cy1 = -coef * ry * x1 / rx;
+  const cx = cos * cx1 - sin * cy1 + (from[0] + to[0]) / 2;
+  const cy = sin * cx1 + cos * cy1 + (from[1] + to[1]) / 2;
+  const angle = (ux, uy, vx, vy) => Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+  const theta1 = angle(1, 0, (x1 - cx1) / rx, (y1 - cy1) / ry);
+  let delta = angle((x1 - cx1) / rx, (y1 - cy1) / ry, (-x1 - cx1) / rx, (-y1 - cy1) / ry);
+  if (!sweep && delta > 0) delta -= 2 * Math.PI;
+  if (sweep && delta < 0) delta += 2 * Math.PI;
+  const pieces = Math.max(1, Math.ceil(Math.abs(delta) / (Math.PI / 2) - 1e-9));
+  const step = delta / pieces;
+  const k = 4 / 3 * Math.tan(step / 4);
+  const map = (x, y) => [cos * x - sin * y + cx, sin * x + cos * y + cy];
+  const out = [];
+  for (let i = 0; i < pieces; i++) {
+    const t1 = theta1 + i * step;
+    const t2 = t1 + step;
+    const [e1x, e1y] = [rx * Math.cos(t1), ry * Math.sin(t1)];
+    const [e2x, e2y] = [rx * Math.cos(t2), ry * Math.sin(t2)];
+    const [d1x, d1y] = [-rx * Math.sin(t1), ry * Math.cos(t1)];
+    const [d2x, d2y] = [-rx * Math.sin(t2), ry * Math.cos(t2)];
+    out.push({
+      kind: "C",
+      c1: map(e1x + k * d1x, e1y + k * d1y),
+      c2: map(e2x - k * d2x, e2y - k * d2y),
+      to: i === pieces - 1 ? to : map(e2x, e2y)
+    });
+  }
+  return out;
+}
+function parsePathData(d) {
+  const s = new NumberScanner(d);
+  const subpaths = [];
+  let current = null;
+  let pen = [0, 0];
+  let start = [0, 0];
+  let lastCubic = null;
+  let lastQuad = null;
+  let curved = false;
+  let command = "";
+  const result = (error2) => ({ subpaths, error: error2, curved });
+  const lineTo = (to) => {
+    current.segments.push({ kind: "L", to });
+    pen = to;
+  };
+  while (!s.done()) {
+    const next = s.peek();
+    if (/[a-zA-Z]/.test(next)) command = s.take();
+    else if (!command || command === "z" || command === "Z") return result(true);
+    const rel = command === command.toLowerCase();
+    const base = rel ? pen : [0, 0];
+    const num2 = () => s.number();
+    const pt = () => {
+      const x = num2();
+      const y = x === null ? null : num2();
+      return x === null || y === null ? null : [x + base[0], y + base[1]];
+    };
+    const upper = command.toUpperCase();
+    if (!current && upper !== "M") return result(true);
+    let cubicCtrl = null;
+    let quadCtrl = null;
+    switch (upper) {
+      case "M": {
+        const p = pt();
+        if (!p) return result(true);
+        current = { start: p, segments: [], closed: false };
+        subpaths.push(current);
+        pen = p;
+        start = p;
+        command = rel ? "l" : "L";
+        break;
+      }
+      case "L": {
+        const p = pt();
+        if (!p) return result(true);
+        lineTo(p);
+        break;
+      }
+      case "H": {
+        const x = num2();
+        if (x === null) return result(true);
+        lineTo([x + base[0], pen[1]]);
+        break;
+      }
+      case "V": {
+        const y = num2();
+        if (y === null) return result(true);
+        lineTo([pen[0], y + base[1]]);
+        break;
+      }
+      case "C":
+      case "S": {
+        let c1;
+        if (upper === "C") c1 = pt();
+        else c1 = lastCubic ? [2 * pen[0] - lastCubic[0], 2 * pen[1] - lastCubic[1]] : pen;
+        const c2 = c1 ? pt() : null;
+        const to = c2 ? pt() : null;
+        if (!c1 || !c2 || !to) return result(true);
+        current.segments.push({ kind: "C", c1, c2, to });
+        cubicCtrl = c2;
+        pen = to;
+        curved = true;
+        break;
+      }
+      case "Q":
+      case "T": {
+        let q;
+        if (upper === "Q") q = pt();
+        else q = lastQuad ? [2 * pen[0] - lastQuad[0], 2 * pen[1] - lastQuad[1]] : pen;
+        const to = q ? pt() : null;
+        if (!q || !to) return result(true);
+        current.segments.push({
+          kind: "C",
+          c1: [pen[0] + 2 / 3 * (q[0] - pen[0]), pen[1] + 2 / 3 * (q[1] - pen[1])],
+          c2: [to[0] + 2 / 3 * (q[0] - to[0]), to[1] + 2 / 3 * (q[1] - to[1])],
+          to
+        });
+        quadCtrl = q;
+        pen = to;
+        curved = true;
+        break;
+      }
+      case "A": {
+        const rx = num2();
+        const ry = rx === null ? null : num2();
+        const rot = ry === null ? null : num2();
+        const large = rot === null ? null : s.flag();
+        const sweep = large === null ? null : s.flag();
+        const to = sweep === null ? null : pt();
+        if (!to) return result(true);
+        const segs = arcToCubics(pen, rx, ry, rot, large, sweep, to);
+        current.segments.push(...segs);
+        if (segs.some((g) => g.kind === "C")) curved = true;
+        pen = to;
+        break;
+      }
+      case "Z":
+        current.closed = true;
+        pen = start;
+        current = { start, segments: [], closed: false };
+        subpaths.push(current);
+        break;
+      default:
+        return result(true);
+    }
+    lastCubic = cubicCtrl;
+    lastQuad = quadCtrl;
+  }
+  return result(false);
+}
+function ellipseSubpath(cx, cy, rx, ry) {
+  const kx = rx * KAPPA;
+  const ky = ry * KAPPA;
+  return {
+    start: [cx + rx, cy],
+    closed: true,
+    segments: [
+      { kind: "C", c1: [cx + rx, cy + ky], c2: [cx + kx, cy + ry], to: [cx, cy + ry] },
+      { kind: "C", c1: [cx - kx, cy + ry], c2: [cx - rx, cy + ky], to: [cx - rx, cy] },
+      { kind: "C", c1: [cx - rx, cy - ky], c2: [cx - kx, cy - ry], to: [cx, cy - ry] },
+      { kind: "C", c1: [cx + kx, cy - ry], c2: [cx + rx, cy - ky], to: [cx + rx, cy] }
+    ]
+  };
+}
+function rectSubpath(x, y, w, h, rx, ry) {
+  if (rx <= 0 || ry <= 0)
+    return {
+      start: [x, y],
+      closed: true,
+      segments: [
+        { kind: "L", to: [x + w, y] },
+        { kind: "L", to: [x + w, y + h] },
+        { kind: "L", to: [x, y + h] },
+        { kind: "L", to: [x, y] }
+      ]
+    };
+  const kx = rx * KAPPA;
+  const ky = ry * KAPPA;
+  const r = x + w;
+  const b = y + h;
+  return {
+    start: [x + rx, y],
+    closed: true,
+    segments: [
+      { kind: "L", to: [r - rx, y] },
+      { kind: "C", c1: [r - rx + kx, y], c2: [r, y + ry - ky], to: [r, y + ry] },
+      { kind: "L", to: [r, b - ry] },
+      { kind: "C", c1: [r, b - ry + ky], c2: [r - rx + kx, b], to: [r - rx, b] },
+      { kind: "L", to: [x + rx, b] },
+      { kind: "C", c1: [x + rx - kx, b], c2: [x, b - ry + ky], to: [x, b - ry] },
+      { kind: "L", to: [x, y + ry] },
+      { kind: "C", c1: [x, y + ry - ky], c2: [x + rx - kx, y], to: [x + rx, y] }
+    ]
+  };
+}
+function distanceToChord(p, a, b) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const len = Math.hypot(dx, dy);
+  if (len === 0) return Math.hypot(p[0] - a[0], p[1] - a[1]);
+  return Math.abs((p[0] - a[0]) * dy - (p[1] - a[1]) * dx) / len;
+}
+function flattenCubic(p0, c1, c2, p3, tolerance, out, depth = 0) {
+  if (depth >= 16 || Math.max(distanceToChord(c1, p0, p3), distanceToChord(c2, p0, p3)) <= tolerance) {
+    out.push(p3);
+    return;
+  }
+  const mid = (a2, b2) => [(a2[0] + b2[0]) / 2, (a2[1] + b2[1]) / 2];
+  const a = mid(p0, c1);
+  const b = mid(c1, c2);
+  const c = mid(c2, p3);
+  const d = mid(a, b);
+  const e = mid(b, c);
+  const m = mid(d, e);
+  flattenCubic(p0, a, d, m, tolerance, out, depth + 1);
+  flattenCubic(m, e, c, p3, tolerance, out, depth + 1);
+}
+function flattenSubpath(sub4, m, tolerance) {
+  const points = [apply(m, sub4.start)];
+  let pen = sub4.start;
+  for (const seg of sub4.segments) {
+    if (seg.kind === "L") points.push(apply(m, seg.to));
+    else
+      flattenCubic(
+        apply(m, pen),
+        apply(m, seg.c1),
+        apply(m, seg.c2),
+        apply(m, seg.to),
+        tolerance,
+        points
+      );
+    pen = seg.to;
+  }
+  if (sub4.closed) {
+    const first2 = points[0];
+    const last = points[points.length - 1];
+    if (last[0] !== first2[0] || last[1] !== first2[1]) points.push(first2);
+  }
+  return points;
+}
+function clipSegment(a, b, r) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  let t0 = 0;
+  let t1 = 1;
+  const edges = [
+    [-dx, a[0] - r.x0],
+    [dx, r.x1 - a[0]],
+    [-dy, a[1] - r.y0],
+    [dy, r.y1 - a[1]]
+  ];
+  for (const [p, q] of edges) {
+    if (p === 0) {
+      if (q < 0) return null;
+      continue;
+    }
+    const t = q / p;
+    if (p < 0) t0 = Math.max(t0, t);
+    else t1 = Math.min(t1, t);
+    if (t0 > t1) return null;
+  }
+  return [
+    [a[0] + t0 * dx, a[1] + t0 * dy],
+    [a[0] + t1 * dx, a[1] + t1 * dy]
+  ];
+}
+function clipPolyline(points, r) {
+  const inside = (p) => p[0] >= r.x0 && p[0] <= r.x1 && p[1] >= r.y0 && p[1] <= r.y1;
+  if (points.every(inside)) return { parts: [points], clipped: false };
+  if (points.length === 1) return { parts: [], clipped: true };
+  const parts = [];
+  let run = [];
+  for (let i = 1; i < points.length; i++) {
+    const seg = clipSegment(points[i - 1], points[i], r);
+    if (!seg) {
+      if (run.length) parts.push(run);
+      run = [];
+      continue;
+    }
+    const [a, b] = seg;
+    const last = run[run.length - 1];
+    if (!run.length || last[0] !== a[0] || last[1] !== a[1]) {
+      if (run.length) parts.push(run);
+      run = [a];
+    }
+    run.push(b);
+    if (b[0] !== points[i][0] || b[1] !== points[i][1]) {
+      parts.push(run);
+      run = [];
+    }
+  }
+  if (run.length) parts.push(run);
+  return { parts, clipped: true };
+}
+function dashPolyline(points, pattern, offset, charge) {
+  const total = pattern.reduce((s, v) => s + v, 0);
+  let index = 0;
+  let remaining = pattern[0];
+  let on = true;
+  let shift = (offset % total + total) % total;
+  while (shift > 0) {
+    const step = Math.min(shift, remaining);
+    remaining -= step;
+    shift -= step;
+    if (remaining <= 0) {
+      index = (index + 1) % pattern.length;
+      remaining = pattern[index];
+      on = !on;
+    }
+  }
+  const dashes = [];
+  let currentDash = on ? [points[0]] : null;
+  for (let i = 1; i < points.length; i++) {
+    let a = points[i - 1];
+    const b = points[i];
+    let segLen = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    while (segLen > remaining) {
+      const t = remaining / segLen;
+      const cut = [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+      if (on && currentDash) {
+        currentDash.push(cut);
+        dashes.push(currentDash);
+        charge(1);
+        currentDash = null;
+      } else currentDash = [cut];
+      on = !on;
+      segLen -= remaining;
+      a = cut;
+      index = (index + 1) % pattern.length;
+      remaining = pattern[index];
+    }
+    remaining -= segLen;
+    if (on && currentDash) currentDash.push(b);
+  }
+  if (on && currentDash && currentDash.length > 1) {
+    dashes.push(currentDash);
+    charge(1);
+  }
+  return dashes;
+}
+function scanFill(rings, evenOdd, brush, spacing, charge) {
+  const edges = [];
+  let minY = Infinity;
+  let maxY = -Infinity;
+  for (const ring of rings)
+    for (let i = 0; i < ring.length; i++) {
+      const a = ring[i];
+      const b = ring[(i + 1) % ring.length];
+      if (a[1] !== b[1]) edges.push([a, b]);
+      minY = Math.min(minY, a[1]);
+      maxY = Math.max(maxY, a[1]);
+    }
+  if (!edges.length) return [];
+  const height = maxY - minY;
+  const lines = Math.max(1, Math.round(height / spacing));
+  const step = height / lines;
+  const out = [];
+  let chains = [];
+  let previous = [];
+  for (let k = 0; k < lines; k++) {
+    const y = minY + step * (k + 0.5);
+    charge(edges.length);
+    const crossings = [];
+    for (const [a, b] of edges) {
+      const lo = Math.min(a[1], b[1]);
+      const hi = Math.max(a[1], b[1]);
+      if (y < lo || y >= hi) continue;
+      crossings.push({
+        x: a[0] + (y - a[1]) / (b[1] - a[1]) * (b[0] - a[0]),
+        dir: b[1] > a[1] ? 1 : -1
+      });
+    }
+    crossings.sort((p, q) => p.x - q.x);
+    const spans = [];
+    let winding = 0;
+    for (let i = 0; i < crossings.length - 1; i++) {
+      winding = evenOdd ? winding ^ 1 : winding + crossings[i].dir;
+      if (winding !== 0 && crossings[i + 1].x > crossings[i].x)
+        spans.push([crossings[i].x, crossings[i + 1].x]);
+    }
+    const merged = [];
+    for (const span of spans) {
+      const last = merged[merged.length - 1];
+      if (last && span[0] <= last[1]) last[1] = Math.max(last[1], span[1]);
+      else merged.push([...span]);
+    }
+    const continues = merged.length === previous.length && merged.every((s, i) => s[0] <= previous[i][1] && s[1] >= previous[i][0]);
+    if (!continues) {
+      out.push(...chains);
+      chains = merged.map(() => []);
+    }
+    merged.forEach(([x0, x1], i) => {
+      const inset = Math.min(brush / 2, (x1 - x0) / 2);
+      const left = [x0 + inset, y];
+      const right = [x1 - inset, y];
+      const forward = k % 2 === 0;
+      const pts = left[0] === right[0] ? [left] : forward ? [left, right] : [right, left];
+      chains[i].push(...pts);
+    });
+    previous = merged;
+  }
+  out.push(...chains);
+  return out.filter((c) => c.length > 0);
+}
+
+// src/utils/svgXml.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+var SvgError = class extends Error {
+  constructor(code, message, location = null) {
+    super(message);
+    this.code = code;
+    this.location = location;
+    this.name = "SvgError";
+  }
+  code;
+  location;
+};
+var NAME_START = /[A-Za-z_À-￿]/;
+var NAME_CHAR = /[A-Za-z0-9_.\-:·À-￿]/;
+var PREDEFINED = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
+function decodeEntities(raw, line) {
+  if (!raw.includes("&")) return raw;
+  return raw.replace(/&([^;&\s]*);?/g, (match, body) => {
+    if (!match.endsWith(";"))
+      throw new SvgError("svg_invalid", `Unterminated character reference on line ${line}`);
+    if (body.startsWith("#")) {
+      const hex3 = body[1] === "x" || body[1] === "X";
+      const digits = body.slice(hex3 ? 2 : 1);
+      const valid = hex3 ? /^[0-9A-Fa-f]{1,6}$/.test(digits) : /^[0-9]{1,7}$/.test(digits);
+      const code = valid ? Number.parseInt(digits, hex3 ? 16 : 10) : NaN;
+      if (!valid || code === 0 || code > 1114111 || code >= 55296 && code <= 57343)
+        throw new SvgError("svg_invalid", `Invalid character reference on line ${line}`);
+      return String.fromCodePoint(code);
+    }
+    if (body in PREDEFINED) return PREDEFINED[body];
+    throw new SvgError(
+      "svg_unsafe",
+      `Named entity "&${body.slice(0, 40)};" on line ${line}: only the five XML entities are allowed`
+    );
+  });
+}
+function parseXml(source, limits) {
+  let pos = 0;
+  let line = 1;
+  let elementCount = 0;
+  const stack = [];
+  let root = null;
+  const fail = (message) => {
+    throw new SvgError("svg_invalid", `${message} on line ${line}`);
+  };
+  const advance = (to) => {
+    for (let i = pos; i < to; i++) if (source.charCodeAt(i) === 10) line++;
+    pos = to;
+  };
+  const indexOrFail = (needle, what) => {
+    const at = source.indexOf(needle, pos);
+    if (at < 0) fail(`Unterminated ${what}`);
+    return at;
+  };
+  if (source.startsWith("<?xml") && /^<\?xml[\s?]/.test(source)) {
+    const end = indexOrFail("?>", "XML declaration");
+    advance(end + 2);
+  }
+  while (pos < source.length) {
+    const lt = source.indexOf("<", pos);
+    const textEnd = lt < 0 ? source.length : lt;
+    if (textEnd > pos) {
+      const raw = source.slice(pos, textEnd);
+      if (stack.length) stack[stack.length - 1].element.text += decodeEntities(raw, line);
+      else if (raw.trim()) fail("Text outside the root element");
+      advance(textEnd);
+      if (lt < 0) break;
+    }
+    if (source.startsWith("<!--", pos)) {
+      const end = indexOrFail("-->", "comment");
+      advance(end + 3);
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", pos)) {
+      if (!stack.length) fail("CDATA outside the root element");
+      const end = indexOrFail("]]>", "CDATA section");
+      stack[stack.length - 1].element.text += source.slice(pos + 9, end);
+      advance(end + 3);
+      continue;
+    }
+    if (source.startsWith("<!", pos))
+      throw new SvgError(
+        "svg_unsafe",
+        `DOCTYPE, ENTITY and other declarations are not allowed (line ${line})`
+      );
+    if (source.startsWith("<?", pos))
+      throw new SvgError("svg_unsafe", `Processing instructions are not allowed (line ${line})`);
+    if (source.startsWith("</", pos)) {
+      const end = indexOrFail(">", "end tag");
+      const name2 = source.slice(pos + 2, end).trim();
+      const open = stack.pop();
+      if (!open || open.element.name !== name2) fail(`Mismatched end tag </${name2.slice(0, 40)}>`);
+      advance(end + 1);
+      continue;
+    }
+    const tagLine = line;
+    let i = pos + 1;
+    if (!NAME_START.test(source[i] ?? "")) fail("Invalid tag");
+    while (i < source.length && NAME_CHAR.test(source[i])) i++;
+    const name = source.slice(pos + 1, i);
+    const rawAttributes = [];
+    let selfClosing = false;
+    for (; ; ) {
+      const ws = i;
+      while (i < source.length && /\s/.test(source[i])) i++;
+      if (i >= source.length) fail("Unterminated start tag");
+      if (source[i] === ">") {
+        i++;
+        break;
+      }
+      if (source.startsWith("/>", i)) {
+        selfClosing = true;
+        i += 2;
+        break;
+      }
+      if (i === ws) fail("Missing whitespace between attributes");
+      const nameStart = i;
+      if (!NAME_START.test(source[i])) fail("Invalid attribute name");
+      while (i < source.length && NAME_CHAR.test(source[i])) i++;
+      const attrName = source.slice(nameStart, i);
+      while (/\s/.test(source[i] ?? "")) i++;
+      if (source[i] !== "=") fail(`Attribute ${attrName.slice(0, 40)} has no value`);
+      i++;
+      while (/\s/.test(source[i] ?? "")) i++;
+      const quote = source[i];
+      if (quote !== '"' && quote !== "'") fail("Attribute values must be quoted");
+      const close = source.indexOf(quote, i + 1);
+      if (close < 0) fail("Unterminated attribute value");
+      const rawValue = source.slice(i + 1, close);
+      if (rawValue.includes("<")) fail("'<' in an attribute value");
+      if (rawAttributes.some((a) => a.name === attrName))
+        fail(`Duplicate attribute ${attrName.slice(0, 40)}`);
+      rawAttributes.push({
+        name: attrName,
+        value: decodeEntities(rawValue.replace(/[\t\n\r]/g, " "), line)
+      });
+      i = close + 1;
+    }
+    advance(i);
+    if (!stack.length && root) fail("More than one root element");
+    elementCount++;
+    if (elementCount > limits.maxElements)
+      throw new SvgError(
+        "svg_complexity_limit",
+        `The document has more than ${limits.maxElements} elements`
+      );
+    if (stack.length + 1 > limits.maxDepth)
+      throw new SvgError("svg_complexity_limit", `Elements nest deeper than ${limits.maxDepth}`);
+    const parentScope = stack.length ? stack[stack.length - 1].scope : /* @__PURE__ */ new Map();
+    const scope2 = new Map(parentScope);
+    for (const a of rawAttributes) {
+      if (a.name === "xmlns") scope2.set("", a.value);
+      else if (a.name.startsWith("xmlns:")) scope2.set(a.name.slice(6), a.value);
+    }
+    const resolve7 = (qualified, isAttribute) => {
+      const colon = qualified.indexOf(":");
+      if (colon < 0) return { local: qualified, ns: isAttribute ? null : scope2.get("") ?? null };
+      const prefix = qualified.slice(0, colon);
+      const local = qualified.slice(colon + 1);
+      if (prefix === "xml") return { local, ns: XML_NS };
+      const ns = scope2.get(prefix);
+      if (ns === void 0) fail(`Undeclared namespace prefix "${prefix.slice(0, 40)}"`);
+      return { local, ns };
+    };
+    const resolved = resolve7(name, false);
+    const element = {
+      name,
+      local: resolved.local,
+      ns: resolved.ns,
+      attributes: rawAttributes.filter((a) => a.name !== "xmlns" && !a.name.startsWith("xmlns:")).map((a) => ({ name: a.name, value: a.value, ...resolve7(a.name, true) })),
+      children: [],
+      text: "",
+      line: tagLine
+    };
+    if (stack.length) stack[stack.length - 1].element.children.push(element);
+    else root = element;
+    if (!selfClosing) stack.push({ element, scope: scope2 });
+  }
+  if (stack.length) fail(`Unclosed element <${stack[stack.length - 1].element.name}>`);
+  if (!root) fail("No root element");
+  return root;
+}
+
+// src/utils/svgAnalyzer.ts
+var SVG_ANALYZER_VERSION = "apple-notes-mcp/svg-analyzer@1";
+var SVG_LIMITS = {
+  maxSourceBytes: 1048576,
+  maxSourceElements: 16384,
+  maxExpandedElements: 16384,
+  maxReferenceExpansions: 8192,
+  maxDepth: 64,
+  maxReferenceDepth: 32,
+  maxPathSegments: 1e5,
+  maxGeometryWork: 1e5,
+  maxDashWork: 1e5,
+  maxScanWork: 5e6,
+  maxStrokes: 4096,
+  maxPoints: 1e5,
+  maxDrawingBytes: 8388608,
+  maxCoordinate: 1e6,
+  maxStrokeWidth: 8192,
+  maxIssues: 128,
+  maxLocationLength: 240
+};
+var TOLERANCE = 0.25;
+var FILL_SCANLINES = 80;
+var MIN_FILL_BRUSH = 2;
+var MAX_FILL_BRUSH = 16;
+var SVG_LOSSES = [
+  "drop-content",
+  "geometry-approximation",
+  "paint-approximation"
+];
+var UNSAFE_ELEMENTS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "foreignObject",
+  "iframe",
+  "object",
+  "embed",
+  "audio",
+  "video",
+  "canvas",
+  "animate",
+  "animateMotion",
+  "animateTransform",
+  "animateColor",
+  "set",
+  "discard",
+  "handler",
+  "listener"
+]);
+var NON_RENDERING = /* @__PURE__ */ new Set([
+  "title",
+  "desc",
+  "metadata",
+  "defs",
+  "symbol",
+  "linearGradient",
+  "radialGradient",
+  "meshgradient",
+  "stop",
+  "clipPath",
+  "mask",
+  "pattern",
+  "marker",
+  "filter",
+  "view",
+  "cursor",
+  "font",
+  "font-face",
+  "glyph",
+  "missing-glyph",
+  "hkern",
+  "vkern",
+  "color-profile"
+]);
+var GEOMETRY = /* @__PURE__ */ new Set(["path", "rect", "circle", "ellipse", "line", "polyline", "polygon"]);
+var TEXT = /* @__PURE__ */ new Set(["text", "tspan", "textPath", "tref"]);
+var STYLE_PROPERTIES = /* @__PURE__ */ new Set([
+  "fill",
+  "stroke",
+  "color",
+  "stroke-width",
+  "opacity",
+  "fill-opacity",
+  "stroke-opacity",
+  "fill-rule",
+  "visibility",
+  "display",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "vector-effect",
+  "overflow"
+]);
+var DROPPED_MODIFIERS = /* @__PURE__ */ new Set([
+  "clip-path",
+  "mask",
+  "filter",
+  "marker",
+  "marker-start",
+  "marker-mid",
+  "marker-end"
+]);
+var IGNORED_PROPERTY = /^(?:font(?:-.*)?|text-.*|letter-spacing|word-spacing|line-height|writing-mode|direction|unicode-bidi|dominant-baseline|alignment-baseline|baseline-shift|shape-rendering|color-rendering|color-interpolation(?:-filters)?|image-rendering|stop-.*|flood-.*|lighting-color|enable-background|solid-.*|clip-rule|isolation|pointer-events|cursor|shape-inside|shape-padding|inline-size|white-space|transform-origin|transform-box|-inkscape-.*|-webkit-.*|-moz-.*)$/;
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object")
+    return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function sha256(text2) {
+  return createHash4("sha256").update(text2).digest("hex");
+}
+var round = (v, digits) => {
+  const r = Number(v.toFixed(digits));
+  return r === 0 ? 0 : r;
+};
+var UNITS = {
+  "": 1,
+  px: 1,
+  pt: 4 / 3,
+  pc: 16,
+  mm: 96 / 25.4,
+  cm: 96 / 2.54,
+  in: 96
+};
+function parseLength(value, percentOf) {
+  if (value === void 0) return null;
+  const m = /^\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)\s*(px|pt|pc|mm|cm|in|%)?\s*$/i.exec(
+    value
+  );
+  if (!m) return null;
+  const n = Number(m[1]);
+  const unit = (m[2] ?? "").toLowerCase();
+  const px = unit === "%" ? n / 100 * percentOf : n * UNITS[unit];
+  return Number.isFinite(px) ? px : null;
+}
+function parseOpacity(value) {
+  const m = /^\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)(%?)\s*$/i.exec(value);
+  if (!m) return null;
+  const n = Number(m[1]) / (m[2] ? 100 : 1);
+  return Math.min(1, Math.max(0, n));
+}
+function viewBoxMatrix(viewBox, width, height, preserve) {
+  const [vx, vy, vw, vh] = viewBox;
+  const parts = (preserve ?? "xMidYMid meet").trim().split(/\s+/);
+  const align = parts[0] === "defer" ? parts[1] ?? "xMidYMid" : parts[0];
+  const slice = parts.includes("slice");
+  let sx = width / vw;
+  let sy = height / vh;
+  if (align !== "none") {
+    const s = slice ? Math.max(sx, sy) : Math.min(sx, sy);
+    sx = s;
+    sy = s;
+  }
+  let tx = -vx * sx;
+  let ty = -vy * sy;
+  if (align !== "none") {
+    const xAlign = /xMid/.test(align) ? 0.5 : /xMax/.test(align) ? 1 : 0;
+    const yAlign = /YMid/.test(align) ? 0.5 : /YMax/.test(align) ? 1 : 0;
+    tx += (width - vw * sx) * xAlign;
+    ty += (height - vh * sy) * yAlign;
+  }
+  return [sx + 0, 0, 0, sy + 0, tx + 0, ty + 0];
+}
+function parseViewBox(value) {
+  if (value === void 0) return null;
+  const nums = parseNumberList(value);
+  if (!nums || nums.length !== 4 || nums[2] <= 0 || nums[3] <= 0) return null;
+  return nums;
+}
+function attr(el, local) {
+  return el.attributes.find((a) => a.local === local && a.ns === null)?.value;
+}
+function href(el) {
+  return el.attributes.find((a) => a.local === "href" && (a.ns === null || a.ns === XLINK_NS))?.value ?? void 0;
+}
+function parseStyleAttribute(value) {
+  const out = [];
+  for (const decl of value.split(";")) {
+    const colon = decl.indexOf(":");
+    if (colon < 0) continue;
+    const name = decl.slice(0, colon).trim().toLowerCase();
+    const val = decl.slice(colon + 1).replace(/!important\s*$/i, "").trim();
+    if (name) out.push([name, val]);
+  }
+  return out;
+}
+function hasText(el) {
+  return el.text.trim().length > 0 || el.children.some(hasText);
+}
+var ACTIVE_SCHEME = /^\s*(?:javascript|vbscript|data)\s*:/i;
+function assertInert(el, location) {
+  if (UNSAFE_ELEMENTS.has(el.local))
+    throw new SvgError(
+      "svg_unsafe",
+      `<${el.local}> is not allowed (scripts, styles, animation and embedded content are refused)`,
+      location
+    );
+  for (const a of el.attributes) {
+    if (/^on/i.test(a.local))
+      throw new SvgError(
+        "svg_unsafe",
+        `Event handler attribute ${a.name} is not allowed`,
+        location
+      );
+    const value = a.value;
+    if (a.local === "href" && (a.ns === null || a.ns === XLINK_NS)) {
+      const target = value.trim();
+      if (el.local === "a") {
+        if (ACTIVE_SCHEME.test(target))
+          throw new SvgError("svg_unsafe", "Link uses an active URL scheme", location);
+      } else if (el.local === "image" && /^data:image\/(?:png|jpeg|gif|webp);/i.test(target)) {
+      } else if (!target.startsWith("#")) {
+        throw new SvgError(
+          "svg_unsafe",
+          `External reference ${target.slice(0, 80)} is not allowed`,
+          location
+        );
+      }
+    }
+    for (const m of value.matchAll(/url\(\s*['"]?([^'")]*)/gi))
+      if (!m[1].trim().startsWith("#"))
+        throw new SvgError("svg_unsafe", "url() references must be local (#id)", location);
+    if (a.local === "style" && /@import|expression\s*\(|javascript\s*:/i.test(value))
+      throw new SvgError("svg_unsafe", "Active content in a style attribute", location);
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const child of el.children) {
+    const n = (counts.get(child.local) ?? 0) + 1;
+    counts.set(child.local, n);
+    assertInert(child, `${location}/${child.local}[${n}]`);
+  }
+}
+var INITIAL_STYLE = {
+  fill: { kind: "color", rgba: [0, 0, 0, 1] },
+  stroke: { kind: "none" },
+  color: [0, 0, 0, 1],
+  fillOpacity: 1,
+  strokeOpacity: 1,
+  strokeWidth: 1,
+  linecap: "butt",
+  linejoin: "miter",
+  dasharray: null,
+  dashoffset: 0,
+  evenOdd: false,
+  visible: true
+};
+var Analyzer = class {
+  constructor(root) {
+    this.root = root;
+    const index = (el) => {
+      this.sourceElements++;
+      const id2 = attr(el, "id");
+      if (id2 !== void 0) this.ids.set(id2, [...this.ids.get(id2) ?? [], el]);
+      el.children.forEach(index);
+    };
+    index(root);
+  }
+  root;
+  issues = [];
+  issueKeys = /* @__PURE__ */ new Set();
+  issuesTruncated = false;
+  strokes = [];
+  points = 0;
+  layers = 0;
+  sourceElements = 0;
+  expandedElements = 0;
+  referenceExpansions = 0;
+  pathSegments = 0;
+  geometryWork = 0;
+  dashWork = 0;
+  scanWork = 0;
+  ids = /* @__PURE__ */ new Map();
+  issue(code, loss, location, message) {
+    const loc = location.length > SVG_LIMITS.maxLocationLength ? "\u2026" + location.slice(-(SVG_LIMITS.maxLocationLength - 1)) : location;
+    const key = `${code}\0${loc}`;
+    if (this.issueKeys.has(key)) return;
+    this.issueKeys.add(key);
+    if (this.issues.length >= SVG_LIMITS.maxIssues) {
+      this.issuesTruncated = true;
+      if (loss && !this.issues.some((i) => i.loss === loss))
+        this.issues.push({ code, loss, location: loc, message });
+      return;
+    }
+    this.issues.push({ code, loss, location: loc, message });
+  }
+  charge(kind, n) {
+    const max = kind === "geometryWork" ? SVG_LIMITS.maxGeometryWork : kind === "dashWork" ? SVG_LIMITS.maxDashWork : SVG_LIMITS.maxScanWork;
+    if (this[kind] + n > max)
+      throw new SvgError("svg_complexity_limit", `The ${kind} budget of ${max} was exceeded`);
+    this[kind] += n;
+  }
+  /** Apply presentation attributes, then the style attribute, onto an inherited style. */
+  resolveStyle(el, inherited, ctx) {
+    const style = { ...inherited };
+    let opacity = 1;
+    let display = true;
+    const declarations = [];
+    for (const a of el.attributes)
+      if (a.ns === null && (STYLE_PROPERTIES.has(a.local) || DROPPED_MODIFIERS.has(a.local) || a.local === "mix-blend-mode" || a.local === "paint-order"))
+        declarations.push([a.local, a.value.trim()]);
+    const styleAttr = attr(el, "style");
+    if (styleAttr) declarations.push(...parseStyleAttribute(styleAttr));
+    const diag = Math.hypot(ctx.viewport[0], ctx.viewport[1]) / Math.SQRT2;
+    for (const [name, value] of declarations) {
+      if (value === "inherit") continue;
+      const invalid2 = () => this.issue(
+        "invalid_value",
+        null,
+        ctx.location,
+        `Ignored invalid ${name} value "${value.slice(0, 40)}"`
+      );
+      switch (name) {
+        case "fill":
+        case "stroke": {
+          const paint = parsePaint(value);
+          if (paint.kind === "invalid") invalid2();
+          else if (name === "fill") style.fill = paint;
+          else style.stroke = paint;
+          break;
+        }
+        case "color": {
+          const c = parseColor(value);
+          if (c) style.color = c;
+          else invalid2();
+          break;
+        }
+        case "stroke-width": {
+          const w = parseLength(value, diag);
+          if (w === null || w < 0) invalid2();
+          else style.strokeWidth = w;
+          break;
+        }
+        case "opacity":
+        case "fill-opacity":
+        case "stroke-opacity": {
+          const o = parseOpacity(value);
+          if (o === null) invalid2();
+          else if (name === "opacity") opacity = o;
+          else if (name === "fill-opacity") style.fillOpacity = o;
+          else style.strokeOpacity = o;
+          break;
+        }
+        case "fill-rule":
+          if (value === "evenodd" || value === "nonzero") style.evenOdd = value === "evenodd";
+          else invalid2();
+          break;
+        case "visibility":
+          style.visible = value === "visible";
+          break;
+        case "display":
+          if (value === "none") display = false;
+          break;
+        case "stroke-linecap":
+          style.linecap = value;
+          break;
+        case "stroke-linejoin":
+          style.linejoin = value;
+          break;
+        case "stroke-dasharray": {
+          if (value === "none") {
+            style.dasharray = null;
+            break;
+          }
+          const list = parseNumberList(value);
+          if (!list || list.some((v) => v < 0)) invalid2();
+          else
+            style.dasharray = list.reduce((s, v) => s + v, 0) > 0 ? list.length % 2 ? [...list, ...list] : list : null;
+          break;
+        }
+        case "stroke-dashoffset": {
+          const o = parseLength(value, diag);
+          if (o === null) invalid2();
+          else style.dashoffset = o;
+          break;
+        }
+        case "stroke-miterlimit":
+        case "vector-effect":
+        case "overflow":
+          break;
+        case "mix-blend-mode":
+          if (value !== "normal")
+            this.issue(
+              "blend_mode_ignored",
+              "paint-approximation",
+              ctx.location,
+              `mix-blend-mode ${value.slice(0, 20)} is drawn as normal`
+            );
+          break;
+        case "paint-order":
+          if (value !== "normal" && !/^fill(\s+stroke)?(\s+markers)?$/.test(value))
+            this.issue(
+              "paint_order_ignored",
+              "paint-approximation",
+              ctx.location,
+              "paint-order is drawn as fill then stroke"
+            );
+          break;
+        default:
+          if (DROPPED_MODIFIERS.has(name)) {
+            if (value !== "none")
+              this.issue(
+                "modifier_dropped",
+                "drop-content",
+                ctx.location,
+                `${name} is not supported and its effect is dropped`
+              );
+          } else if (!IGNORED_PROPERTY.test(name)) {
+            this.issue(
+              "ignored_property",
+              null,
+              ctx.location,
+              `Ignored style property ${name.slice(0, 40)}`
+            );
+          }
+      }
+    }
+    return { style, opacity, display };
+  }
+  propertyValue(el, name) {
+    const styleAttr = attr(el, "style");
+    const fromStyle = styleAttr ? parseStyleAttribute(styleAttr).filter(([n]) => n === name).pop() : void 0;
+    return fromStyle ? fromStyle[1] : attr(el, name);
+  }
+  run() {
+    const root = this.root;
+    if (root.local !== "svg" || root.ns !== null && root.ns !== SVG_NS)
+      throw new SvgError("svg_invalid", "The root element is not <svg>");
+    assertInert(root, "svg");
+    const viewBox = parseViewBox(attr(root, "viewBox"));
+    if (attr(root, "viewBox") !== void 0 && !viewBox)
+      this.issue("invalid_value", null, "svg", "Ignored an invalid viewBox");
+    let width = parseLength(attr(root, "width"), viewBox ? viewBox[2] : 300);
+    let height = parseLength(attr(root, "height"), viewBox ? viewBox[3] : 150);
+    if (width === null || width <= 0) width = viewBox ? viewBox[2] : 300;
+    if (height === null || height <= 0) height = viewBox ? viewBox[3] : 150;
+    if (!viewBox && (attr(root, "width") === void 0 || attr(root, "height") === void 0))
+      this.issue(
+        "viewport_assumed",
+        null,
+        "svg",
+        `No viewBox or size; assumed a ${width}x${height} viewport`
+      );
+    if (width > SVG_LIMITS.maxCoordinate || height > SVG_LIMITS.maxCoordinate)
+      throw new SvgError("svg_complexity_limit", "The viewport is too large");
+    const matrix = viewBox ? viewBoxMatrix(viewBox, width, height, attr(root, "preserveAspectRatio")) : IDENTITY;
+    const ctx = {
+      matrix,
+      style: INITIAL_STYLE,
+      opacity: 1,
+      clip: { x0: 0, y0: 0, x1: width, y1: height },
+      viewport: viewBox ? [viewBox[2], viewBox[3]] : [width, height],
+      location: "svg",
+      refDepth: 0,
+      depth: 0,
+      refStack: []
+    };
+    const { style, opacity, display } = this.resolveStyle(root, INITIAL_STYLE, ctx);
+    if (display) {
+      const layersBefore = this.layers;
+      this.container(root, { ...ctx, style, opacity });
+      if (opacity < 1 && this.layers - layersBefore > 1)
+        this.issue(
+          "group_opacity",
+          "paint-approximation",
+          "svg",
+          "Group opacity is applied to each stroke separately"
+        );
+    }
+    return { width: round(width, 3), height: round(height, 3) };
+  }
+  expand() {
+    this.expandedElements++;
+    if (this.expandedElements > SVG_LIMITS.maxExpandedElements)
+      throw new SvgError(
+        "svg_complexity_limit",
+        `More than ${SVG_LIMITS.maxExpandedElements} elements after expanding references`
+      );
+  }
+  /** Walk an element's children with its own style and transform applied. */
+  container(el, ctx) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const child of el.children) {
+      const n = (counts.get(child.local) ?? 0) + 1;
+      counts.set(child.local, n);
+      const id2 = attr(child, "id");
+      this.element(child, {
+        ...ctx,
+        depth: ctx.depth + 1,
+        location: `${ctx.location}/${child.local}[${n}]${id2 ? `#${id2}` : ""}`
+      });
+    }
+  }
+  element(el, parent) {
+    this.expand();
+    if (parent.depth > SVG_LIMITS.maxDepth)
+      throw new SvgError(
+        "svg_complexity_limit",
+        `Elements nest deeper than ${SVG_LIMITS.maxDepth}`
+      );
+    if (el.ns !== null && el.ns !== SVG_NS) return;
+    const name = el.local;
+    if (NON_RENDERING.has(name)) return;
+    const { style, opacity, display } = this.resolveStyle(el, parent.style, parent);
+    if (!display) return;
+    let matrix = parent.matrix;
+    const transform2 = attr(el, "transform");
+    if (transform2 !== void 0) {
+      const t = parseTransform(transform2);
+      if (!t) {
+        this.issue(
+          "invalid_transform",
+          "drop-content",
+          parent.location,
+          "An element with an invalid transform is not drawn"
+        );
+        return;
+      }
+      matrix = multiply(matrix, t);
+    }
+    const ctx = { ...parent, matrix, style, opacity: parent.opacity * opacity };
+    const layersBefore = this.layers;
+    if (name === "g" || name === "a") this.container(el, ctx);
+    else if (name === "svg") this.nestedViewport(el, ctx, el, void 0);
+    else if (name === "use") this.use(el, ctx);
+    else if (GEOMETRY.has(name)) this.shape(el, ctx);
+    else if (TEXT.has(name)) {
+      if (hasText(el))
+        this.issue(
+          "text_dropped",
+          "drop-content",
+          ctx.location,
+          "Text is not converted to strokes"
+        );
+    } else if (name === "image")
+      this.issue(
+        "image_dropped",
+        "drop-content",
+        ctx.location,
+        "Embedded images are not converted to strokes"
+      );
+    else if (name === "switch")
+      this.issue(
+        "switch_dropped",
+        "drop-content",
+        ctx.location,
+        "Conditional <switch> content is not evaluated"
+      );
+    else
+      this.issue(
+        "unsupported_element",
+        "drop-content",
+        ctx.location,
+        `<${name.slice(0, 40)}> is not supported`
+      );
+    if (opacity < 1 && this.layers - layersBefore > 1)
+      this.issue(
+        "group_opacity",
+        "paint-approximation",
+        ctx.location,
+        "Group opacity is applied to each stroke separately"
+      );
+  }
+  /** A nested <svg> or a <use>d <symbol>: a new viewport with its own viewBox. */
+  nestedViewport(el, ctx, sizeFrom, useEl) {
+    const [pw, ph] = ctx.viewport;
+    const x = useEl ? 0 : parseLength(attr(el, "x"), pw) ?? 0;
+    const y = useEl ? 0 : parseLength(attr(el, "y"), ph) ?? 0;
+    const viewBox = parseViewBox(attr(el, "viewBox"));
+    const w = parseLength(attr(sizeFrom, "width") ?? attr(el, "width"), pw) ?? (useEl && viewBox ? viewBox[2] : pw);
+    const h = parseLength(attr(sizeFrom, "height") ?? attr(el, "height"), ph) ?? (useEl && viewBox ? viewBox[3] : ph);
+    if (w <= 0 || h <= 0) return;
+    let matrix = multiply(ctx.matrix, [1, 0, 0, 1, x, y]);
+    let clip = ctx.clip;
+    const overflow = this.propertyValue(el, "overflow");
+    if (overflow !== "visible" && overflow !== "auto") {
+      const [a, b, c, d, e, f] = matrix;
+      if (b === 0 && c === 0) {
+        const xs = [e, a * w + e].sort((p, q) => p - q);
+        const ys = [f, d * h + f].sort((p, q) => p - q);
+        const r = { x0: xs[0], y0: ys[0], x1: xs[1], y1: ys[1] };
+        clip = clip ? {
+          x0: Math.max(clip.x0, r.x0),
+          y0: Math.max(clip.y0, r.y0),
+          x1: Math.min(clip.x1, r.x1),
+          y1: Math.min(clip.y1, r.y1)
+        } : r;
+      } else {
+        this.issue(
+          "viewport_clip_skipped",
+          "geometry-approximation",
+          ctx.location,
+          "A rotated or skewed nested viewport is not clipped"
+        );
+      }
+    }
+    if (viewBox)
+      matrix = multiply(matrix, viewBoxMatrix(viewBox, w, h, attr(el, "preserveAspectRatio")));
+    this.container(el, {
+      ...ctx,
+      matrix,
+      clip,
+      viewport: viewBox ? [viewBox[2], viewBox[3]] : [w, h]
+    });
+  }
+  use(el, ctx) {
+    const ref = href(el);
+    if (!ref) return;
+    const id2 = ref.trim().slice(1);
+    const targets = this.ids.get(id2) ?? [];
+    if (targets.length === 0) {
+      this.issue(
+        "reference_missing",
+        null,
+        ctx.location,
+        `#${id2.slice(0, 60)} does not exist; nothing is drawn`
+      );
+      return;
+    }
+    if (targets.length > 1)
+      throw new SvgError(
+        "svg_reference_invalid",
+        `More than one element has id ${id2.slice(0, 60)}`,
+        ctx.location
+      );
+    if (ctx.refStack.includes(id2))
+      throw new SvgError(
+        "svg_reference_invalid",
+        `Reference cycle through #${id2.slice(0, 60)}`,
+        ctx.location
+      );
+    if (ctx.refDepth + 1 > SVG_LIMITS.maxReferenceDepth)
+      throw new SvgError(
+        "svg_complexity_limit",
+        `References nest deeper than ${SVG_LIMITS.maxReferenceDepth}`
+      );
+    this.referenceExpansions++;
+    if (this.referenceExpansions > SVG_LIMITS.maxReferenceExpansions)
+      throw new SvgError(
+        "svg_complexity_limit",
+        `More than ${SVG_LIMITS.maxReferenceExpansions} reference expansions`
+      );
+    const target = targets[0];
+    const [pw, ph] = ctx.viewport;
+    const x = parseLength(attr(el, "x"), pw) ?? 0;
+    const y = parseLength(attr(el, "y"), ph) ?? 0;
+    const inner = {
+      ...ctx,
+      matrix: multiply(ctx.matrix, [1, 0, 0, 1, x, y]),
+      location: `${ctx.location}>#${id2}`,
+      refDepth: ctx.refDepth + 1,
+      refStack: [...ctx.refStack, id2]
+    };
+    if (target.ns !== null && target.ns !== SVG_NS) return;
+    if (target.local === "symbol" || target.local === "svg") {
+      this.expand();
+      const { style, opacity, display } = this.resolveStyle(target, inner.style, inner);
+      if (!display) return;
+      const layersBefore = this.layers;
+      const symbolCtx = { ...inner, style, opacity: inner.opacity * opacity };
+      this.nestedViewport(target, symbolCtx, el, el);
+      if (opacity < 1 && this.layers - layersBefore > 1)
+        this.issue(
+          "group_opacity",
+          "paint-approximation",
+          inner.location,
+          "Group opacity is applied to each stroke separately"
+        );
+    } else {
+      this.element(target, inner);
+    }
+  }
+  subpathsFor(el, ctx) {
+    const [pw, ph] = ctx.viewport;
+    const diag = Math.hypot(pw, ph) / Math.SQRT2;
+    const len = (name, of) => parseLength(attr(el, name), of);
+    const bad = (what) => {
+      this.issue("invalid_geometry", null, ctx.location, `${what}; the element is not drawn`);
+      return null;
+    };
+    switch (el.local) {
+      case "path": {
+        const d = attr(el, "d");
+        if (d === void 0 || !d.trim()) return null;
+        const parsed = parsePathData(d);
+        const segs = parsed.subpaths.reduce((s, p) => s + p.segments.length, 0);
+        this.pathSegments += segs;
+        if (this.pathSegments > SVG_LIMITS.maxPathSegments)
+          throw new SvgError(
+            "svg_complexity_limit",
+            `More than ${SVG_LIMITS.maxPathSegments} path segments`
+          );
+        if (parsed.error)
+          this.issue(
+            "path_data_error",
+            "drop-content",
+            ctx.location,
+            "Path data has an error; the part after it is dropped"
+          );
+        return { subpaths: parsed.subpaths, fillable: true };
+      }
+      case "rect": {
+        const x = len("x", pw) ?? 0;
+        const y = len("y", ph) ?? 0;
+        const w = len("width", pw) ?? 0;
+        const h = len("height", ph) ?? 0;
+        if (w < 0 || h < 0) return bad("Negative rectangle size");
+        if (w === 0 || h === 0) return null;
+        let rx = len("rx", pw);
+        let ry = len("ry", ph);
+        if (rx !== null && rx < 0) rx = null;
+        if (ry !== null && ry < 0) ry = null;
+        rx = Math.min(rx ?? ry ?? 0, w / 2);
+        ry = Math.min(ry ?? rx, h / 2);
+        return {
+          subpaths: [rectSubpath(x, y, w, h, rx, ry)],
+          fillable: true
+        };
+      }
+      case "circle":
+      case "ellipse": {
+        const cx = len("cx", pw) ?? 0;
+        const cy = len("cy", ph) ?? 0;
+        let rx;
+        let ry;
+        if (el.local === "circle") rx = ry = len("r", diag) ?? 0;
+        else {
+          rx = len("rx", pw);
+          ry = len("ry", ph);
+          rx = rx ?? ry ?? 0;
+          ry = ry ?? rx;
+        }
+        if (rx < 0 || ry < 0) return bad("Negative radius");
+        if (rx === 0 || ry === 0) return null;
+        return { subpaths: [ellipseSubpath(cx, cy, rx, ry)], fillable: true };
+      }
+      case "line": {
+        const p0 = [len("x1", pw) ?? 0, len("y1", ph) ?? 0];
+        const p1 = [len("x2", pw) ?? 0, len("y2", ph) ?? 0];
+        return {
+          subpaths: [{ start: p0, segments: [{ kind: "L", to: p1 }], closed: false }],
+          fillable: false
+        };
+      }
+      default: {
+        const nums = parseNumberList(attr(el, "points") ?? "");
+        if (!nums) return bad("Malformed points list");
+        const pts = [];
+        for (let i = 0; i + 1 < nums.length; i += 2) pts.push([nums[i], nums[i + 1]]);
+        if (nums.length % 2)
+          this.issue(
+            "invalid_geometry",
+            null,
+            ctx.location,
+            "Odd number of coordinates; the last one is ignored"
+          );
+        if (pts.length < 2) return null;
+        return {
+          subpaths: [
+            {
+              start: pts[0],
+              segments: pts.slice(1).map((to) => ({ kind: "L", to })),
+              closed: el.local === "polygon"
+            }
+          ],
+          fillable: true
+        };
+      }
+    }
+  }
+  emit(points, color, width, ctx) {
+    const rounded = [];
+    for (const p of points) {
+      const q = [round(p[0], 3), round(p[1], 3)];
+      const last = rounded[rounded.length - 1];
+      if (!last || last[0] !== q[0] || last[1] !== q[1]) rounded.push(q);
+    }
+    if (!rounded.length) return;
+    if (width > SVG_LIMITS.maxStrokeWidth)
+      throw new SvgError(
+        "svg_complexity_limit",
+        `A stroke is wider than ${SVG_LIMITS.maxStrokeWidth}`,
+        ctx.location
+      );
+    this.strokes.push({
+      ink: "monoline",
+      color: [round(color[0], 4), round(color[1], 4), round(color[2], 4), round(color[3], 4)],
+      width: round(width, 3),
+      points: rounded
+    });
+    this.points += rounded.length;
+    if (this.strokes.length > SVG_LIMITS.maxStrokes)
+      throw new SvgError(
+        "svg_complexity_limit",
+        `More than ${SVG_LIMITS.maxStrokes} output strokes`
+      );
+    if (this.points > SVG_LIMITS.maxPoints)
+      throw new SvgError("svg_complexity_limit", `More than ${SVG_LIMITS.maxPoints} output points`);
+  }
+  clipped(polyline, ctx) {
+    if (!ctx.clip) return [polyline];
+    const { parts, clipped } = clipPolyline(polyline, ctx.clip);
+    if (clipped)
+      this.issue(
+        "viewport_clipped",
+        "geometry-approximation",
+        ctx.location,
+        "Content outside the viewport is clipped"
+      );
+    return parts;
+  }
+  paintColor(paint, style) {
+    if (paint.kind === "color") return paint.rgba;
+    if (paint.kind === "current") return style.color;
+    if (paint.kind === "url") return "url";
+    return null;
+  }
+  shape(el, ctx) {
+    const geometry = this.subpathsFor(el, ctx);
+    if (!geometry || !ctx.style.visible) return;
+    const { style } = ctx;
+    const polylines = geometry.subpaths.filter((s) => s.segments.length > 0).map((s) => {
+      const pts = flattenSubpath(s, ctx.matrix, TOLERANCE);
+      this.charge("geometryWork", pts.length);
+      if (pts.some(
+        (p) => !(Math.abs(p[0]) <= SVG_LIMITS.maxCoordinate && Math.abs(p[1]) <= SVG_LIMITS.maxCoordinate)
+      ))
+        throw new SvgError(
+          "svg_geometry_invalid",
+          "Geometry is not finite or exceeds the coordinate limit",
+          ctx.location
+        );
+      return pts;
+    });
+    if (!polylines.length) return;
+    const fill = this.paintColor(style.fill, style);
+    const stroke = style.strokeWidth > 0 ? this.paintColor(style.stroke, style) : null;
+    if (fill === "url")
+      this.issue(
+        "paint_server_dropped",
+        "drop-content",
+        ctx.location,
+        "Gradient or pattern fill is not supported and is dropped"
+      );
+    if (stroke === "url")
+      this.issue(
+        "paint_server_dropped",
+        "drop-content",
+        ctx.location,
+        "Gradient or pattern stroke is not supported and is dropped"
+      );
+    if (fill && fill !== "url" && geometry.fillable) {
+      const alpha = fill[3] * style.fillOpacity * ctx.opacity;
+      const rings = polylines.filter((p) => p.length >= 3);
+      if (alpha > 0 && rings.length) {
+        const ys = rings.flat().map((p) => p[1]);
+        const h = Math.max(...ys) - Math.min(...ys);
+        const brush = Math.min(MAX_FILL_BRUSH, Math.max(MIN_FILL_BRUSH, h / FILL_SCANLINES));
+        const chains = scanFill(
+          rings,
+          style.evenOdd,
+          brush,
+          brush * 0.8,
+          (n) => this.charge("scanWork", n)
+        );
+        if (chains.length) {
+          this.issue(
+            "fill_as_strokes",
+            "paint-approximation",
+            ctx.location,
+            "Filled area is drawn with overlapping strokes"
+          );
+          this.layers++;
+          for (const chain of chains)
+            for (const part of this.clipped(chain, ctx))
+              this.emit(part, [fill[0], fill[1], fill[2], alpha], brush, ctx);
+        }
+      }
+    }
+    if (stroke && stroke !== "url") {
+      const alpha = stroke[3] * style.strokeOpacity * ctx.opacity;
+      if (alpha > 0) {
+        const nonScaling = this.propertyValue(el, "vector-effect") === "non-scaling-stroke";
+        const [s1, s2] = scales(ctx.matrix);
+        const mean = Math.sqrt(s1 * s2);
+        if (!nonScaling && s2 > 0 && s1 / s2 > 1.001)
+          this.issue(
+            "nonuniform_stroke",
+            "geometry-approximation",
+            ctx.location,
+            "Non-uniformly scaled stroke is drawn with one width"
+          );
+        const width = nonScaling ? style.strokeWidth : style.strokeWidth * mean;
+        if (width > 0) {
+          const openPath = geometry.subpaths.some((s) => s.segments.length > 0 && !s.closed) || style.dasharray;
+          if (style.linecap !== "round" && openPath)
+            this.issue(
+              "cap_approximated",
+              "geometry-approximation",
+              ctx.location,
+              `stroke-linecap ${style.linecap.slice(0, 20)} is drawn round`
+            );
+          if (style.linejoin !== "round" && polylines.some((p) => p.length > 2))
+            this.issue(
+              "join_approximated",
+              "geometry-approximation",
+              ctx.location,
+              `stroke-linejoin ${style.linejoin.slice(0, 20)} is drawn round`
+            );
+          let pieces = polylines;
+          if (style.dasharray) {
+            const k = nonScaling ? 1 : mean;
+            const pattern = style.dasharray.map((v) => v * k);
+            pieces = polylines.flatMap(
+              (p) => dashPolyline(p, pattern, style.dashoffset * k, (n) => this.charge("dashWork", n))
+            );
+          }
+          this.layers++;
+          for (const piece of pieces) {
+            const zeroLength = piece.every((p) => p[0] === piece[0][0] && p[1] === piece[0][1]);
+            if (zeroLength && style.linecap !== "round") continue;
+            for (const part of this.clipped(zeroLength ? [piece[0]] : piece, ctx))
+              this.emit(part, [stroke[0], stroke[1], stroke[2], alpha], width, ctx);
+          }
+        }
+      }
+    }
+  }
+};
+function analysisFor(source, analyzer, viewport) {
+  const drawing = {
+    version: 1,
+    width: viewport.width,
+    height: viewport.height,
+    strokes: analyzer.strokes
+  };
+  const drawingJson = canonicalJson(drawing);
+  if (drawingJson.length > SVG_LIMITS.maxDrawingBytes)
+    throw new SvgError(
+      "normalized_drawing_too_large",
+      `The normalized drawing exceeds ${SVG_LIMITS.maxDrawingBytes} bytes`
+    );
+  const importable = drawing.strokes.length > 0;
+  if (!importable)
+    analyzer.issue("empty_drawing", null, "svg", "Nothing drawable remains after conversion");
+  const requiredLosses = SVG_LOSSES.filter((loss) => analyzer.issues.some((i) => i.loss === loss));
+  const classification = !importable || requiredLosses.includes("drop-content") ? "unsupported" : requiredLosses.length ? "lossy" : "safe";
+  const analysis = {
+    analyzer: SVG_ANALYZER_VERSION,
+    source: { sha256: sha256(source), bytes: source.length },
+    classification,
+    importable,
+    defaultWriteAllowed: importable && classification === "safe",
+    requiredLosses,
+    viewport,
+    counts: {
+      sourceElements: analyzer.sourceElements,
+      expandedElements: analyzer.expandedElements,
+      referenceExpansions: analyzer.referenceExpansions,
+      pathSegments: analyzer.pathSegments,
+      strokes: drawing.strokes.length,
+      points: analyzer.points,
+      geometryWork: { used: analyzer.geometryWork, max: SVG_LIMITS.maxGeometryWork },
+      dashWork: { used: analyzer.dashWork, max: SVG_LIMITS.maxDashWork },
+      scanWork: { used: analyzer.scanWork, max: SVG_LIMITS.maxScanWork }
+    },
+    drawingBytes: drawingJson.length,
+    issues: analyzer.issues,
+    issuesTruncated: analyzer.issuesTruncated
+  };
+  const analysisDigest = "sha256:" + sha256(canonicalJson({ analysis, drawing }));
+  return { analysis: { ...analysis, analysisDigest }, drawing };
+}
+function analyzeSvgBuffer(source) {
+  if (source.length > SVG_LIMITS.maxSourceBytes)
+    throw new SvgError(
+      "svg_file_invalid",
+      `The SVG is larger than ${SVG_LIMITS.maxSourceBytes} bytes`
+    );
+  let text2;
+  try {
+    text2 = new TextDecoder("utf-8", { fatal: true }).decode(source);
+  } catch {
+    throw new SvgError("svg_file_invalid", "The SVG is not valid UTF-8");
+  }
+  if (text2.charCodeAt(0) === 65279) text2 = text2.slice(1);
+  const root = parseXml(text2, {
+    maxElements: SVG_LIMITS.maxSourceElements,
+    maxDepth: SVG_LIMITS.maxDepth
+  });
+  const analyzer = new Analyzer(root);
+  const viewport = analyzer.run();
+  return analysisFor(source, analyzer, viewport);
+}
+function readSvgSource(path10) {
+  let fd;
+  try {
+    fd = openSync6(path10, constants6.O_RDONLY | constants6.O_NOFOLLOW | constants6.O_NONBLOCK);
+  } catch (error2) {
+    if (error2.code === "ELOOP")
+      throw new SvgError("svg_file_invalid", "The SVG path is a symbolic link");
+    throw new SvgError("svg_file_invalid", "The SVG file does not exist or cannot be read");
+  }
+  try {
+    const info = fstatSync6(fd);
+    if (!info.isFile())
+      throw new SvgError("svg_file_invalid", "The SVG path is not a regular file");
+    if (info.size > SVG_LIMITS.maxSourceBytes)
+      throw new SvgError(
+        "svg_file_invalid",
+        `The SVG is larger than ${SVG_LIMITS.maxSourceBytes} bytes`
+      );
+    const buffer = Buffer.alloc(SVG_LIMITS.maxSourceBytes + 1);
+    let total = 0;
+    for (; ; ) {
+      const n = readSync4(fd, buffer, total, buffer.length - total, null);
+      if (n === 0) break;
+      total += n;
+      if (total > SVG_LIMITS.maxSourceBytes)
+        throw new SvgError(
+          "svg_file_invalid",
+          `The SVG is larger than ${SVG_LIMITS.maxSourceBytes} bytes`
+        );
+    }
+    return buffer.subarray(0, total);
+  } finally {
+    closeSync6(fd);
+  }
+}
+function analyzeSvgFile(path10) {
+  return analyzeSvgBuffer(readSvgSource(path10));
+}
+
+// src/tools/svgAnalysis.ts
+function runSvgAnalysis(args, roots = allowedSaveRoots()) {
+  let abs;
+  try {
+    abs = assertReadableInRoots(args.path, roots, "SVG file");
+  } catch (error2) {
+    throw new CodedError(error2.message, {
+      code: "validation_error",
+      svgCode: "svg_file_invalid"
+    });
+  }
+  try {
+    const result = analyzeSvgFile(abs);
+    return {
+      ...result.analysis,
+      ...args.includeDrawing ? { drawing: result.drawing } : {}
+    };
+  } catch (error2) {
+    if (error2 instanceof SvgError)
+      throw new CodedError(`SVG refused (${error2.code}): ${error2.message}`, {
+        code: "validation_error",
+        svgCode: error2.code,
+        ...error2.location ? { location: error2.location } : {}
+      });
+    throw error2;
+  }
+}
+function registerSvgAnalysis(server2) {
+  const inputSchema = {
+    path: external_exports.string().min(1).max(4096).describe(
+      `Absolute path of one .svg file (home, temp, or /Volumes; not a symbolic link; at most ${SVG_LIMITS.maxSourceBytes} bytes of UTF-8)`
+    ),
+    includeDrawing: external_exports.boolean().optional().describe(
+      "Also return the normalized drawing (strokes with sRGB color, width and points). Off by default: it can be large."
+    )
+  };
+  server2.registerTool(
+    "analyze-svg",
+    {
+      description: "Use when: checking whether an SVG file can be represented as editable monoline strokes, and what that conversion would approximate or drop.\nReturns: classification (safe, lossy, unsupported), importable, defaultWriteAllowed, requiredLosses (geometry-approximation, paint-approximation, drop-content), issues with element locations, counts and work budgets, the source SHA-256, and analysisDigest, a SHA-256 over the canonical analysis and normalized drawing. includeDrawing adds the drawing.\nDo not use when: you want to attach the SVG file itself to a note (add-attachment).\nSafety: read-only and local. Opens no Notes data and makes no network request. Scripts, event handlers, style elements, animation, DOCTYPE/entities and external resources are refused with svgCode svg_unsafe; malformed files with svg_invalid; oversized work with svg_complexity_limit.",
+      inputSchema,
+      outputSchema: external_exports.object({ classification: external_exports.string().optional() }).passthrough(),
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    (async (args) => {
+      try {
+        const result = runSvgAnalysis(args);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          structuredContent: result
+        };
+      } catch (error2) {
+        return errorResult(error2 instanceof Error ? error2.message : String(error2), error2);
+      }
+    })
+  );
+}
+
 // src/tools/nativeTagsBridge.ts
 var noteId2 = exactIdInput(
   "ICNote",
@@ -52499,7 +54575,7 @@ function formatShortcutSetup(report) {
 
 // src/services/publicHelper.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import {
   chmodSync,
   existsSync as existsSync14,
@@ -52565,7 +54641,7 @@ function publicHelperInstallDir(env = process.env) {
   return join24(homedir19(), "Library", "Application Support", "apple-notes-mcp", "public-helper");
 }
 function sha256Hex(data) {
-  return createHash4("sha256").update(data).digest("hex");
+  return createHash5("sha256").update(data).digest("hex");
 }
 function inspectPublicHelper(deps = defaultPublicHelperDeps()) {
   const installDir = publicHelperInstallDir(deps.env);
@@ -53113,7 +55189,7 @@ import { join as join26 } from "node:path";
 
 // src/services/privateHelper.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync15, readFileSync as readFileSync5 } from "node:fs";
 import { homedir as homedir20 } from "node:os";
 import { dirname as dirname9, join as join25, resolve as resolve6 } from "node:path";
@@ -53177,7 +55253,7 @@ function helperInstallDir(env = process.env) {
   return join25(homedir20(), "Library", "Application Support", "apple-notes-mcp", "private-helper");
 }
 function sha256Hex2(data) {
-  return createHash5("sha256").update(data).digest("hex");
+  return createHash6("sha256").update(data).digest("hex");
 }
 function inspectInstallation(deps = defaultDeps2()) {
   const installDir = helperInstallDir(deps.env);
@@ -53762,6 +55838,7 @@ var server = new McpServer({
 var notesManager = new AppleNotesManager();
 registerDirectOperations(server, notesManager);
 registerFolderDelete(server, notesManager);
+registerSvgAnalysis(server);
 registerNativeTagsBridge(server, notesManager);
 registerNativeOperations(server, notesManager);
 registerPrivateHelperTools(server, notesManager);