wiki-plugin-wmap 1.0.0

package/client/wmap.js

@@ -0,0 +1,4630 @@
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // node_modules/.pnpm/canvas@3.2.0/node_modules/canvas/browser.js
+  var require_browser = __commonJS({
+    "node_modules/.pnpm/canvas@3.2.0/node_modules/canvas/browser.js"(exports) {
+      exports.createCanvas = function(width, height) {
+        return Object.assign(document.createElement("canvas"), { width, height });
+      };
+      exports.createImageData = function(array, width, height) {
+        switch (arguments.length) {
+          case 0:
+            return new ImageData();
+          case 1:
+            return new ImageData(array);
+          case 2:
+            return new ImageData(array, width);
+          default:
+            return new ImageData(array, width, height);
+        }
+      };
+      exports.loadImage = function(src, options) {
+        return new Promise(function(resolve, reject) {
+          const image = Object.assign(document.createElement("img"), options);
+          function cleanup() {
+            image.onload = null;
+            image.onerror = null;
+          }
+          image.onload = function() {
+            cleanup();
+            resolve(image);
+          };
+          image.onerror = function() {
+            cleanup();
+            reject(new Error('Failed to load the image "' + src + '"'));
+          };
+          image.src = src;
+        });
+      };
+    }
+  });
+
+  // node_modules/.pnpm/dompurify@3.3.1/node_modules/dompurify/dist/purify.cjs.js
+  var require_purify_cjs = __commonJS({
+    "node_modules/.pnpm/dompurify@3.3.1/node_modules/dompurify/dist/purify.cjs.js"(exports, module) {
+      "use strict";
+      var {
+        entries,
+        setPrototypeOf,
+        isFrozen,
+        getPrototypeOf,
+        getOwnPropertyDescriptor
+      } = Object;
+      var {
+        freeze,
+        seal,
+        create
+      } = Object;
+      var {
+        apply,
+        construct
+      } = typeof Reflect !== "undefined" && Reflect;
+      if (!freeze) {
+        freeze = function freeze2(x) {
+          return x;
+        };
+      }
+      if (!seal) {
+        seal = function seal2(x) {
+          return x;
+        };
+      }
+      if (!apply) {
+        apply = function apply2(func, thisArg) {
+          for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+            args[_key - 2] = arguments[_key];
+          }
+          return func.apply(thisArg, args);
+        };
+      }
+      if (!construct) {
+        construct = function construct2(Func) {
+          for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+            args[_key2 - 1] = arguments[_key2];
+          }
+          return new Func(...args);
+        };
+      }
+      var arrayForEach = unapply(Array.prototype.forEach);
+      var arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
+      var arrayPop = unapply(Array.prototype.pop);
+      var arrayPush = unapply(Array.prototype.push);
+      var arraySplice = unapply(Array.prototype.splice);
+      var stringToLowerCase = unapply(String.prototype.toLowerCase);
+      var stringToString = unapply(String.prototype.toString);
+      var stringMatch = unapply(String.prototype.match);
+      var stringReplace = unapply(String.prototype.replace);
+      var stringIndexOf = unapply(String.prototype.indexOf);
+      var stringTrim = unapply(String.prototype.trim);
+      var objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
+      var regExpTest = unapply(RegExp.prototype.test);
+      var typeErrorCreate = unconstruct(TypeError);
+      function unapply(func) {
+        return function(thisArg) {
+          if (thisArg instanceof RegExp) {
+            thisArg.lastIndex = 0;
+          }
+          for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+            args[_key3 - 1] = arguments[_key3];
+          }
+          return apply(func, thisArg, args);
+        };
+      }
+      function unconstruct(Func) {
+        return function() {
+          for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+            args[_key4] = arguments[_key4];
+          }
+          return construct(Func, args);
+        };
+      }
+      function addToSet(set, array) {
+        let transformCaseFunc = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : stringToLowerCase;
+        if (setPrototypeOf) {
+          setPrototypeOf(set, null);
+        }
+        let l = array.length;
+        while (l--) {
+          let element = array[l];
+          if (typeof element === "string") {
+            const lcElement = transformCaseFunc(element);
+            if (lcElement !== element) {
+              if (!isFrozen(array)) {
+                array[l] = lcElement;
+              }
+              element = lcElement;
+            }
+          }
+          set[element] = true;
+        }
+        return set;
+      }
+      function cleanArray(array) {
+        for (let index = 0; index < array.length; index++) {
+          const isPropertyExist = objectHasOwnProperty(array, index);
+          if (!isPropertyExist) {
+            array[index] = null;
+          }
+        }
+        return array;
+      }
+      function clone2(object2) {
+        const newObject = create(null);
+        for (const [property, value] of entries(object2)) {
+          const isPropertyExist = objectHasOwnProperty(object2, property);
+          if (isPropertyExist) {
+            if (Array.isArray(value)) {
+              newObject[property] = cleanArray(value);
+            } else if (value && typeof value === "object" && value.constructor === Object) {
+              newObject[property] = clone2(value);
+            } else {
+              newObject[property] = value;
+            }
+          }
+        }
+        return newObject;
+      }
+      function lookupGetter(object2, prop) {
+        while (object2 !== null) {
+          const desc = getOwnPropertyDescriptor(object2, prop);
+          if (desc) {
+            if (desc.get) {
+              return unapply(desc.get);
+            }
+            if (typeof desc.value === "function") {
+              return unapply(desc.value);
+            }
+          }
+          object2 = getPrototypeOf(object2);
+        }
+        function fallbackValue() {
+          return null;
+        }
+        return fallbackValue;
+      }
+      var html$1 = freeze(["a", "abbr", "acronym", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "decorator", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "marquee", "menu", "menuitem", "meter", "nav", "nobr", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "search", "section", "select", "shadow", "slot", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "var", "video", "wbr"]);
+      var svg$1 = freeze(["svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "enterkeyhint", "exportparts", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "inputmode", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "part", "path", "pattern", "polygon", "polyline", "radialgradient", "rect", "stop", "style", "switch", "symbol", "text", "textpath", "title", "tref", "tspan", "view", "vkern"]);
+      var svgFilters = freeze(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]);
+      var svgDisallowed = freeze(["animate", "color-profile", "cursor", "discard", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]);
+      var mathMl$1 = freeze(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover", "mprescripts"]);
+      var mathMlDisallowed = freeze(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]);
+      var text = freeze(["#text"]);
+      var html = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "exportparts", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inert", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "part", "pattern", "placeholder", "playsinline", "popover", "popovertarget", "popovertargetaction", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "slot", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "wrap", "xmlns", "slot"]);
+      var svg = freeze(["accent-height", "accumulate", "additive", "alignment-baseline", "amplitude", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "exponent", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "intercept", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "mask-type", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "slope", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "tablevalues", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]);
+      var mathMl = freeze(["accent", "accentunder", "align", "bevelled", "close", "columnsalign", "columnlines", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lspace", "lquote", "mathbackground", "mathcolor", "mathsize", "mathvariant", "maxsize", "minsize", "movablelimits", "notation", "numalign", "open", "rowalign", "rowlines", "rowspacing", "rowspan", "rspace", "rquote", "scriptlevel", "scriptminsize", "scriptsizemultiplier", "selection", "separator", "separators", "stretchy", "subscriptshift", "supscriptshift", "symmetric", "voffset", "width", "xmlns"]);
+      var xml = freeze(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]);
+      var MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm);
+      var ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
+      var TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm);
+      var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/);
+      var ARIA_ATTR = seal(/^aria-[\-\w]+$/);
+      var IS_ALLOWED_URI = seal(
+        /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
+        // eslint-disable-line no-useless-escape
+      );
+      var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+      var ATTR_WHITESPACE = seal(
+        /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g
+        // eslint-disable-line no-control-regex
+      );
+      var DOCTYPE_NAME = seal(/^html$/i);
+      var CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
+      var EXPRESSIONS = /* @__PURE__ */ Object.freeze({
+        __proto__: null,
+        ARIA_ATTR,
+        ATTR_WHITESPACE,
+        CUSTOM_ELEMENT,
+        DATA_ATTR,
+        DOCTYPE_NAME,
+        ERB_EXPR,
+        IS_ALLOWED_URI,
+        IS_SCRIPT_OR_DATA,
+        MUSTACHE_EXPR,
+        TMPLIT_EXPR
+      });
+      var NODE_TYPE = {
+        element: 1,
+        attribute: 2,
+        text: 3,
+        cdataSection: 4,
+        entityReference: 5,
+        // Deprecated
+        entityNode: 6,
+        // Deprecated
+        progressingInstruction: 7,
+        comment: 8,
+        document: 9,
+        documentType: 10,
+        documentFragment: 11,
+        notation: 12
+        // Deprecated
+      };
+      var getGlobal = function getGlobal2() {
+        return typeof window === "undefined" ? null : window;
+      };
+      var _createTrustedTypesPolicy = function _createTrustedTypesPolicy2(trustedTypes, purifyHostElement) {
+        if (typeof trustedTypes !== "object" || typeof trustedTypes.createPolicy !== "function") {
+          return null;
+        }
+        let suffix = null;
+        const ATTR_NAME = "data-tt-policy-suffix";
+        if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
+          suffix = purifyHostElement.getAttribute(ATTR_NAME);
+        }
+        const policyName = "dompurify" + (suffix ? "#" + suffix : "");
+        try {
+          return trustedTypes.createPolicy(policyName, {
+            createHTML(html2) {
+              return html2;
+            },
+            createScriptURL(scriptUrl) {
+              return scriptUrl;
+            }
+          });
+        } catch (_) {
+          console.warn("TrustedTypes policy " + policyName + " could not be created.");
+          return null;
+        }
+      };
+      var _createHooksMap = function _createHooksMap2() {
+        return {
+          afterSanitizeAttributes: [],
+          afterSanitizeElements: [],
+          afterSanitizeShadowDOM: [],
+          beforeSanitizeAttributes: [],
+          beforeSanitizeElements: [],
+          beforeSanitizeShadowDOM: [],
+          uponSanitizeAttribute: [],
+          uponSanitizeElement: [],
+          uponSanitizeShadowNode: []
+        };
+      };
+      function createDOMPurify() {
+        let window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
+        const DOMPurify2 = (root) => createDOMPurify(root);
+        DOMPurify2.version = "3.3.1";
+        DOMPurify2.removed = [];
+        if (!window2 || !window2.document || window2.document.nodeType !== NODE_TYPE.document || !window2.Element) {
+          DOMPurify2.isSupported = false;
+          return DOMPurify2;
+        }
+        let {
+          document: document2
+        } = window2;
+        const originalDocument = document2;
+        const currentScript = originalDocument.currentScript;
+        const {
+          DocumentFragment,
+          HTMLTemplateElement,
+          Node,
+          Element,
+          NodeFilter,
+          NamedNodeMap = window2.NamedNodeMap || window2.MozNamedAttrMap,
+          HTMLFormElement,
+          DOMParser,
+          trustedTypes
+        } = window2;
+        const ElementPrototype = Element.prototype;
+        const cloneNode = lookupGetter(ElementPrototype, "cloneNode");
+        const remove = lookupGetter(ElementPrototype, "remove");
+        const getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
+        const getChildNodes = lookupGetter(ElementPrototype, "childNodes");
+        const getParentNode = lookupGetter(ElementPrototype, "parentNode");
+        if (typeof HTMLTemplateElement === "function") {
+          const template = document2.createElement("template");
+          if (template.content && template.content.ownerDocument) {
+            document2 = template.content.ownerDocument;
+          }
+        }
+        let trustedTypesPolicy;
+        let emptyHTML = "";
+        const {
+          implementation,
+          createNodeIterator,
+          createDocumentFragment,
+          getElementsByTagName
+        } = document2;
+        const {
+          importNode
+        } = originalDocument;
+        let hooks = _createHooksMap();
+        DOMPurify2.isSupported = typeof entries === "function" && typeof getParentNode === "function" && implementation && implementation.createHTMLDocument !== void 0;
+        const {
+          MUSTACHE_EXPR: MUSTACHE_EXPR2,
+          ERB_EXPR: ERB_EXPR2,
+          TMPLIT_EXPR: TMPLIT_EXPR2,
+          DATA_ATTR: DATA_ATTR2,
+          ARIA_ATTR: ARIA_ATTR2,
+          IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA2,
+          ATTR_WHITESPACE: ATTR_WHITESPACE2,
+          CUSTOM_ELEMENT: CUSTOM_ELEMENT2
+        } = EXPRESSIONS;
+        let {
+          IS_ALLOWED_URI: IS_ALLOWED_URI$1
+        } = EXPRESSIONS;
+        let ALLOWED_TAGS = null;
+        const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);
+        let ALLOWED_ATTR = null;
+        const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);
+        let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {
+          tagNameCheck: {
+            writable: true,
+            configurable: false,
+            enumerable: true,
+            value: null
+          },
+          attributeNameCheck: {
+            writable: true,
+            configurable: false,
+            enumerable: true,
+            value: null
+          },
+          allowCustomizedBuiltInElements: {
+            writable: true,
+            configurable: false,
+            enumerable: true,
+            value: false
+          }
+        }));
+        let FORBID_TAGS = null;
+        let FORBID_ATTR = null;
+        const EXTRA_ELEMENT_HANDLING = Object.seal(create(null, {
+          tagCheck: {
+            writable: true,
+            configurable: false,
+            enumerable: true,
+            value: null
+          },
+          attributeCheck: {
+            writable: true,
+            configurable: false,
+            enumerable: true,
+            value: null
+          }
+        }));
+        let ALLOW_ARIA_ATTR = true;
+        let ALLOW_DATA_ATTR = true;
+        let ALLOW_UNKNOWN_PROTOCOLS = false;
+        let ALLOW_SELF_CLOSE_IN_ATTR = true;
+        let SAFE_FOR_TEMPLATES = false;
+        let SAFE_FOR_XML = true;
+        let WHOLE_DOCUMENT = false;
+        let SET_CONFIG = false;
+        let FORCE_BODY = false;
+        let RETURN_DOM = false;
+        let RETURN_DOM_FRAGMENT = false;
+        let RETURN_TRUSTED_TYPE = false;
+        let SANITIZE_DOM = true;
+        let SANITIZE_NAMED_PROPS = false;
+        const SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
+        let KEEP_CONTENT = true;
+        let IN_PLACE = false;
+        let USE_PROFILES = {};
+        let FORBID_CONTENTS = null;
+        const DEFAULT_FORBID_CONTENTS = addToSet({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]);
+        let DATA_URI_TAGS = null;
+        const DEFAULT_DATA_URI_TAGS = addToSet({}, ["audio", "video", "img", "source", "image", "track"]);
+        let URI_SAFE_ATTRIBUTES = null;
+        const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns"]);
+        const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+        const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+        const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+        let NAMESPACE = HTML_NAMESPACE;
+        let IS_EMPTY_INPUT = false;
+        let ALLOWED_NAMESPACES = null;
+        const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
+        let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
+        let HTML_INTEGRATION_POINTS = addToSet({}, ["annotation-xml"]);
+        const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ["title", "style", "font", "a", "script"]);
+        let PARSER_MEDIA_TYPE = null;
+        const SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
+        const DEFAULT_PARSER_MEDIA_TYPE = "text/html";
+        let transformCaseFunc = null;
+        let CONFIG = null;
+        const formElement = document2.createElement("form");
+        const isRegexOrFunction = function isRegexOrFunction2(testValue) {
+          return testValue instanceof RegExp || testValue instanceof Function;
+        };
+        const _parseConfig = function _parseConfig2() {
+          let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+          if (CONFIG && CONFIG === cfg) {
+            return;
+          }
+          if (!cfg || typeof cfg !== "object") {
+            cfg = {};
+          }
+          cfg = clone2(cfg);
+          PARSER_MEDIA_TYPE = // eslint-disable-next-line unicorn/prefer-includes
+          SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
+          transformCaseFunc = PARSER_MEDIA_TYPE === "application/xhtml+xml" ? stringToString : stringToLowerCase;
+          ALLOWED_TAGS = objectHasOwnProperty(cfg, "ALLOWED_TAGS") ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
+          ALLOWED_ATTR = objectHasOwnProperty(cfg, "ALLOWED_ATTR") ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
+          ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, "ALLOWED_NAMESPACES") ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
+          URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") ? addToSet(clone2(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
+          DATA_URI_TAGS = objectHasOwnProperty(cfg, "ADD_DATA_URI_TAGS") ? addToSet(clone2(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
+          FORBID_CONTENTS = objectHasOwnProperty(cfg, "FORBID_CONTENTS") ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
+          FORBID_TAGS = objectHasOwnProperty(cfg, "FORBID_TAGS") ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone2({});
+          FORBID_ATTR = objectHasOwnProperty(cfg, "FORBID_ATTR") ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone2({});
+          USE_PROFILES = objectHasOwnProperty(cfg, "USE_PROFILES") ? cfg.USE_PROFILES : false;
+          ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
+          ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
+          ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false;
+          ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false;
+          SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false;
+          SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false;
+          WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false;
+          RETURN_DOM = cfg.RETURN_DOM || false;
+          RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false;
+          RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false;
+          FORCE_BODY = cfg.FORCE_BODY || false;
+          SANITIZE_DOM = cfg.SANITIZE_DOM !== false;
+          SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false;
+          KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
+          IN_PLACE = cfg.IN_PLACE || false;
+          IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
+          NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+          MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS || MATHML_TEXT_INTEGRATION_POINTS;
+          HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS || HTML_INTEGRATION_POINTS;
+          CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
+          if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
+            CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+          }
+          if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
+            CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
+          }
+          if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === "boolean") {
+            CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
+          }
+          if (SAFE_FOR_TEMPLATES) {
+            ALLOW_DATA_ATTR = false;
+          }
+          if (RETURN_DOM_FRAGMENT) {
+            RETURN_DOM = true;
+          }
+          if (USE_PROFILES) {
+            ALLOWED_TAGS = addToSet({}, text);
+            ALLOWED_ATTR = [];
+            if (USE_PROFILES.html === true) {
+              addToSet(ALLOWED_TAGS, html$1);
+              addToSet(ALLOWED_ATTR, html);
+            }
+            if (USE_PROFILES.svg === true) {
+              addToSet(ALLOWED_TAGS, svg$1);
+              addToSet(ALLOWED_ATTR, svg);
+              addToSet(ALLOWED_ATTR, xml);
+            }
+            if (USE_PROFILES.svgFilters === true) {
+              addToSet(ALLOWED_TAGS, svgFilters);
+              addToSet(ALLOWED_ATTR, svg);
+              addToSet(ALLOWED_ATTR, xml);
+            }
+            if (USE_PROFILES.mathMl === true) {
+              addToSet(ALLOWED_TAGS, mathMl$1);
+              addToSet(ALLOWED_ATTR, mathMl);
+              addToSet(ALLOWED_ATTR, xml);
+            }
+          }
+          if (cfg.ADD_TAGS) {
+            if (typeof cfg.ADD_TAGS === "function") {
+              EXTRA_ELEMENT_HANDLING.tagCheck = cfg.ADD_TAGS;
+            } else {
+              if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+                ALLOWED_TAGS = clone2(ALLOWED_TAGS);
+              }
+              addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
+            }
+          }
+          if (cfg.ADD_ATTR) {
+            if (typeof cfg.ADD_ATTR === "function") {
+              EXTRA_ELEMENT_HANDLING.attributeCheck = cfg.ADD_ATTR;
+            } else {
+              if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+                ALLOWED_ATTR = clone2(ALLOWED_ATTR);
+              }
+              addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
+            }
+          }
+          if (cfg.ADD_URI_SAFE_ATTR) {
+            addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
+          }
+          if (cfg.FORBID_CONTENTS) {
+            if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+              FORBID_CONTENTS = clone2(FORBID_CONTENTS);
+            }
+            addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
+          }
+          if (cfg.ADD_FORBID_CONTENTS) {
+            if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+              FORBID_CONTENTS = clone2(FORBID_CONTENTS);
+            }
+            addToSet(FORBID_CONTENTS, cfg.ADD_FORBID_CONTENTS, transformCaseFunc);
+          }
+          if (KEEP_CONTENT) {
+            ALLOWED_TAGS["#text"] = true;
+          }
+          if (WHOLE_DOCUMENT) {
+            addToSet(ALLOWED_TAGS, ["html", "head", "body"]);
+          }
+          if (ALLOWED_TAGS.table) {
+            addToSet(ALLOWED_TAGS, ["tbody"]);
+            delete FORBID_TAGS.tbody;
+          }
+          if (cfg.TRUSTED_TYPES_POLICY) {
+            if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== "function") {
+              throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+            }
+            if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== "function") {
+              throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+            }
+            trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
+            emptyHTML = trustedTypesPolicy.createHTML("");
+          } else {
+            if (trustedTypesPolicy === void 0) {
+              trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+            }
+            if (trustedTypesPolicy !== null && typeof emptyHTML === "string") {
+              emptyHTML = trustedTypesPolicy.createHTML("");
+            }
+          }
+          if (freeze) {
+            freeze(cfg);
+          }
+          CONFIG = cfg;
+        };
+        const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
+        const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
+        const _checkValidNamespace = function _checkValidNamespace2(element) {
+          let parent = getParentNode(element);
+          if (!parent || !parent.tagName) {
+            parent = {
+              namespaceURI: NAMESPACE,
+              tagName: "template"
+            };
+          }
+          const tagName = stringToLowerCase(element.tagName);
+          const parentTagName = stringToLowerCase(parent.tagName);
+          if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
+            return false;
+          }
+          if (element.namespaceURI === SVG_NAMESPACE) {
+            if (parent.namespaceURI === HTML_NAMESPACE) {
+              return tagName === "svg";
+            }
+            if (parent.namespaceURI === MATHML_NAMESPACE) {
+              return tagName === "svg" && (parentTagName === "annotation-xml" || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+            }
+            return Boolean(ALL_SVG_TAGS[tagName]);
+          }
+          if (element.namespaceURI === MATHML_NAMESPACE) {
+            if (parent.namespaceURI === HTML_NAMESPACE) {
+              return tagName === "math";
+            }
+            if (parent.namespaceURI === SVG_NAMESPACE) {
+              return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
+            }
+            return Boolean(ALL_MATHML_TAGS[tagName]);
+          }
+          if (element.namespaceURI === HTML_NAMESPACE) {
+            if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+              return false;
+            }
+            if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+              return false;
+            }
+            return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+          }
+          if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[element.namespaceURI]) {
+            return true;
+          }
+          return false;
+        };
+        const _forceRemove = function _forceRemove2(node) {
+          arrayPush(DOMPurify2.removed, {
+            element: node
+          });
+          try {
+            getParentNode(node).removeChild(node);
+          } catch (_) {
+            remove(node);
+          }
+        };
+        const _removeAttribute = function _removeAttribute2(name, element) {
+          try {
+            arrayPush(DOMPurify2.removed, {
+              attribute: element.getAttributeNode(name),
+              from: element
+            });
+          } catch (_) {
+            arrayPush(DOMPurify2.removed, {
+              attribute: null,
+              from: element
+            });
+          }
+          element.removeAttribute(name);
+          if (name === "is") {
+            if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+              try {
+                _forceRemove(element);
+              } catch (_) {
+              }
+            } else {
+              try {
+                element.setAttribute(name, "");
+              } catch (_) {
+              }
+            }
+          }
+        };
+        const _initDocument = function _initDocument2(dirty) {
+          let doc = null;
+          let leadingWhitespace = null;
+          if (FORCE_BODY) {
+            dirty = "<remove></remove>" + dirty;
+          } else {
+            const matches = stringMatch(dirty, /^[\r\n\t ]+/);
+            leadingWhitespace = matches && matches[0];
+          }
+          if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && NAMESPACE === HTML_NAMESPACE) {
+            dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + "</body></html>";
+          }
+          const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+          if (NAMESPACE === HTML_NAMESPACE) {
+            try {
+              doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
+            } catch (_) {
+            }
+          }
+          if (!doc || !doc.documentElement) {
+            doc = implementation.createDocument(NAMESPACE, "template", null);
+            try {
+              doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
+            } catch (_) {
+            }
+          }
+          const body = doc.body || doc.documentElement;
+          if (dirty && leadingWhitespace) {
+            body.insertBefore(document2.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+          }
+          if (NAMESPACE === HTML_NAMESPACE) {
+            return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? "html" : "body")[0];
+          }
+          return WHOLE_DOCUMENT ? doc.documentElement : body;
+        };
+        const _createNodeIterator = function _createNodeIterator2(root) {
+          return createNodeIterator.call(
+            root.ownerDocument || root,
+            root,
+            // eslint-disable-next-line no-bitwise
+            NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION,
+            null
+          );
+        };
+        const _isClobbered = function _isClobbered2(element) {
+          return element instanceof HTMLFormElement && (typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function");
+        };
+        const _isNode = function _isNode2(value) {
+          return typeof Node === "function" && value instanceof Node;
+        };
+        function _executeHooks(hooks2, currentNode, data) {
+          arrayForEach(hooks2, (hook) => {
+            hook.call(DOMPurify2, currentNode, data, CONFIG);
+          });
+        }
+        const _sanitizeElements = function _sanitizeElements2(currentNode) {
+          let content = null;
+          _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+          if (_isClobbered(currentNode)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          const tagName = transformCaseFunc(currentNode.nodeName);
+          _executeHooks(hooks.uponSanitizeElement, currentNode, {
+            tagName,
+            allowedTags: ALLOWED_TAGS
+          });
+          if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (!(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName])) {
+            if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
+              if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
+                return false;
+              }
+              if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
+                return false;
+              }
+            }
+            if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+              const parentNode = getParentNode(currentNode) || currentNode.parentNode;
+              const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+              if (childNodes && parentNode) {
+                const childCount = childNodes.length;
+                for (let i = childCount - 1; i >= 0; --i) {
+                  const childClone = cloneNode(childNodes[i], true);
+                  childClone.__removalCount = (currentNode.__removalCount || 0) + 1;
+                  parentNode.insertBefore(childClone, getNextSibling(currentNode));
+                }
+              }
+            }
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
+            content = currentNode.textContent;
+            arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+              content = stringReplace(content, expr, " ");
+            });
+            if (currentNode.textContent !== content) {
+              arrayPush(DOMPurify2.removed, {
+                element: currentNode.cloneNode()
+              });
+              currentNode.textContent = content;
+            }
+          }
+          _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+          return false;
+        };
+        const _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
+          if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) {
+            return false;
+          }
+          if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR2, lcName)) ;
+          else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR2, lcName)) ;
+          else if (EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag)) ;
+          else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+            if (
+              // First condition does a very basic check if a) it's basically a valid custom element tagname AND
+              // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+              // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
+              _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName, lcTag)) || // Alternative, second condition checks if it's an `is`-attribute, AND
+              // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+              lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))
+            ) ;
+            else {
+              return false;
+            }
+          } else if (URI_SAFE_ATTRIBUTES[lcName]) ;
+          else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE2, ""))) ;
+          else if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag]) ;
+          else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA2, stringReplace(value, ATTR_WHITESPACE2, ""))) ;
+          else if (value) {
+            return false;
+          } else ;
+          return true;
+        };
+        const _isBasicCustomElement = function _isBasicCustomElement2(tagName) {
+          return tagName !== "annotation-xml" && stringMatch(tagName, CUSTOM_ELEMENT2);
+        };
+        const _sanitizeAttributes = function _sanitizeAttributes2(currentNode) {
+          _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
+          const {
+            attributes
+          } = currentNode;
+          if (!attributes || _isClobbered(currentNode)) {
+            return;
+          }
+          const hookEvent = {
+            attrName: "",
+            attrValue: "",
+            keepAttr: true,
+            allowedAttributes: ALLOWED_ATTR,
+            forceKeepAttr: void 0
+          };
+          let l = attributes.length;
+          while (l--) {
+            const attr = attributes[l];
+            const {
+              name,
+              namespaceURI,
+              value: attrValue
+            } = attr;
+            const lcName = transformCaseFunc(name);
+            const initValue = attrValue;
+            let value = name === "value" ? initValue : stringTrim(initValue);
+            hookEvent.attrName = lcName;
+            hookEvent.attrValue = value;
+            hookEvent.keepAttr = true;
+            hookEvent.forceKeepAttr = void 0;
+            _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
+            value = hookEvent.attrValue;
+            if (SANITIZE_NAMED_PROPS && (lcName === "id" || lcName === "name")) {
+              _removeAttribute(name, currentNode);
+              value = SANITIZE_NAMED_PROPS_PREFIX + value;
+            }
+            if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|title|textarea)/i, value)) {
+              _removeAttribute(name, currentNode);
+              continue;
+            }
+            if (lcName === "attributename" && stringMatch(value, "href")) {
+              _removeAttribute(name, currentNode);
+              continue;
+            }
+            if (hookEvent.forceKeepAttr) {
+              continue;
+            }
+            if (!hookEvent.keepAttr) {
+              _removeAttribute(name, currentNode);
+              continue;
+            }
+            if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
+              _removeAttribute(name, currentNode);
+              continue;
+            }
+            if (SAFE_FOR_TEMPLATES) {
+              arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+                value = stringReplace(value, expr, " ");
+              });
+            }
+            const lcTag = transformCaseFunc(currentNode.nodeName);
+            if (!_isValidAttribute(lcTag, lcName, value)) {
+              _removeAttribute(name, currentNode);
+              continue;
+            }
+            if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function") {
+              if (namespaceURI) ;
+              else {
+                switch (trustedTypes.getAttributeType(lcTag, lcName)) {
+                  case "TrustedHTML": {
+                    value = trustedTypesPolicy.createHTML(value);
+                    break;
+                  }
+                  case "TrustedScriptURL": {
+                    value = trustedTypesPolicy.createScriptURL(value);
+                    break;
+                  }
+                }
+              }
+            }
+            if (value !== initValue) {
+              try {
+                if (namespaceURI) {
+                  currentNode.setAttributeNS(namespaceURI, name, value);
+                } else {
+                  currentNode.setAttribute(name, value);
+                }
+                if (_isClobbered(currentNode)) {
+                  _forceRemove(currentNode);
+                } else {
+                  arrayPop(DOMPurify2.removed);
+                }
+              } catch (_) {
+                _removeAttribute(name, currentNode);
+              }
+            }
+          }
+          _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
+        };
+        const _sanitizeShadowDOM = function _sanitizeShadowDOM2(fragment) {
+          let shadowNode = null;
+          const shadowIterator = _createNodeIterator(fragment);
+          _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
+          while (shadowNode = shadowIterator.nextNode()) {
+            _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
+            _sanitizeElements(shadowNode);
+            _sanitizeAttributes(shadowNode);
+            if (shadowNode.content instanceof DocumentFragment) {
+              _sanitizeShadowDOM2(shadowNode.content);
+            }
+          }
+          _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
+        };
+        DOMPurify2.sanitize = function(dirty) {
+          let cfg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+          let body = null;
+          let importedNode = null;
+          let currentNode = null;
+          let returnNode = null;
+          IS_EMPTY_INPUT = !dirty;
+          if (IS_EMPTY_INPUT) {
+            dirty = "<!-->";
+          }
+          if (typeof dirty !== "string" && !_isNode(dirty)) {
+            if (typeof dirty.toString === "function") {
+              dirty = dirty.toString();
+              if (typeof dirty !== "string") {
+                throw typeErrorCreate("dirty is not a string, aborting");
+              }
+            } else {
+              throw typeErrorCreate("toString is not a function");
+            }
+          }
+          if (!DOMPurify2.isSupported) {
+            return dirty;
+          }
+          if (!SET_CONFIG) {
+            _parseConfig(cfg);
+          }
+          DOMPurify2.removed = [];
+          if (typeof dirty === "string") {
+            IN_PLACE = false;
+          }
+          if (IN_PLACE) {
+            if (dirty.nodeName) {
+              const tagName = transformCaseFunc(dirty.nodeName);
+              if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+                throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
+              }
+            }
+          } else if (dirty instanceof Node) {
+            body = _initDocument("<!---->");
+            importedNode = body.ownerDocument.importNode(dirty, true);
+            if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === "BODY") {
+              body = importedNode;
+            } else if (importedNode.nodeName === "HTML") {
+              body = importedNode;
+            } else {
+              body.appendChild(importedNode);
+            }
+          } else {
+            if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && // eslint-disable-next-line unicorn/prefer-includes
+            dirty.indexOf("<") === -1) {
+              return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+            }
+            body = _initDocument(dirty);
+            if (!body) {
+              return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : "";
+            }
+          }
+          if (body && FORCE_BODY) {
+            _forceRemove(body.firstChild);
+          }
+          const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
+          while (currentNode = nodeIterator.nextNode()) {
+            _sanitizeElements(currentNode);
+            _sanitizeAttributes(currentNode);
+            if (currentNode.content instanceof DocumentFragment) {
+              _sanitizeShadowDOM(currentNode.content);
+            }
+          }
+          if (IN_PLACE) {
+            return dirty;
+          }
+          if (RETURN_DOM) {
+            if (RETURN_DOM_FRAGMENT) {
+              returnNode = createDocumentFragment.call(body.ownerDocument);
+              while (body.firstChild) {
+                returnNode.appendChild(body.firstChild);
+              }
+            } else {
+              returnNode = body;
+            }
+            if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {
+              returnNode = importNode.call(originalDocument, returnNode, true);
+            }
+            return returnNode;
+          }
+          let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+          if (WHOLE_DOCUMENT && ALLOWED_TAGS["!doctype"] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
+            serializedHTML = "<!DOCTYPE " + body.ownerDocument.doctype.name + ">\n" + serializedHTML;
+          }
+          if (SAFE_FOR_TEMPLATES) {
+            arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+              serializedHTML = stringReplace(serializedHTML, expr, " ");
+            });
+          }
+          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+        };
+        DOMPurify2.setConfig = function() {
+          let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+          _parseConfig(cfg);
+          SET_CONFIG = true;
+        };
+        DOMPurify2.clearConfig = function() {
+          CONFIG = null;
+          SET_CONFIG = false;
+        };
+        DOMPurify2.isValidAttribute = function(tag, attr, value) {
+          if (!CONFIG) {
+            _parseConfig({});
+          }
+          const lcTag = transformCaseFunc(tag);
+          const lcName = transformCaseFunc(attr);
+          return _isValidAttribute(lcTag, lcName, value);
+        };
+        DOMPurify2.addHook = function(entryPoint, hookFunction) {
+          if (typeof hookFunction !== "function") {
+            return;
+          }
+          arrayPush(hooks[entryPoint], hookFunction);
+        };
+        DOMPurify2.removeHook = function(entryPoint, hookFunction) {
+          if (hookFunction !== void 0) {
+            const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+            return index === -1 ? void 0 : arraySplice(hooks[entryPoint], index, 1)[0];
+          }
+          return arrayPop(hooks[entryPoint]);
+        };
+        DOMPurify2.removeHooks = function(entryPoint) {
+          hooks[entryPoint] = [];
+        };
+        DOMPurify2.removeAllHooks = function() {
+          hooks = _createHooksMap();
+        };
+        return DOMPurify2;
+      }
+      var purify = createDOMPurify();
+      module.exports = purify;
+    }
+  });
+
+  // node_modules/.pnpm/isomorphic-dompurify@2.34.0_canvas@3.2.0/node_modules/isomorphic-dompurify/browser.js
+  var require_browser2 = __commonJS({
+    "node_modules/.pnpm/isomorphic-dompurify@2.34.0_canvas@3.2.0/node_modules/isomorphic-dompurify/browser.js"(exports, module) {
+      module.exports = self.DOMPurify || (self.DOMPurify = require_purify_cjs().default || require_purify_cjs());
+    }
+  });
+
+  // node_modules/.pnpm/wmap-parser@1.0.1/node_modules/wmap-parser/src/index.js
+  var kLineSplitter = /\r\n|\r|\n/;
+  function parse(source) {
+    const components = [];
+    const dependencies = [];
+    const notes = [];
+    const stages = [];
+    const groups = [];
+    const inertias = [];
+    const evolutions = [];
+    const lines = source.split(kLineSplitter);
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      const entity = parseLine(line);
+      if (!entity) continue;
+      switch (entity.type) {
+        case "component":
+          components.push({
+            label: entity.label,
+            coordinates: entity.coordinates,
+            shape: entity.shape
+          });
+          break;
+        case "dependency":
+          dependencies.push({
+            from: entity.from,
+            to: entity.to,
+            isDirected: entity.isDirected
+          });
+          break;
+        case "note":
+          notes.push({
+            coordinates: entity.coordinates,
+            text: entity.text
+          });
+          break;
+        case "stage":
+          stages.push({
+            stage: entity.stage,
+            value: entity.value
+          });
+          break;
+        case "group":
+          groups.push({
+            components: entity.components
+          });
+          break;
+        case "inertia":
+          inertias.push({
+            component: entity.component
+          });
+          break;
+        case "evolution":
+          evolutions.push({
+            component: entity.component,
+            value: entity.value
+          });
+          break;
+      }
+    }
+    return {
+      components,
+      dependencies,
+      notes,
+      stages,
+      groups,
+      inertias,
+      evolutions
+    };
+  }
+  function parseLine(line) {
+    const length = line.length;
+    let i = 0;
+    while (i < length && isWhitespace(line[i])) i++;
+    if (i >= length) return null;
+    if (line[i] === "[") {
+      return parseKeywordEntity(line, i, length);
+    }
+    return parseComponentOrDependency(line, length);
+  }
+  function parseKeywordEntity(line, start, length) {
+    let i = start + 1;
+    const keywordStart = i;
+    while (i < length && line[i] !== "]") i++;
+    if (i >= length) return null;
+    const keyword = line.substring(keywordStart, i).trim().toLowerCase();
+    i++;
+    while (i < length && isWhitespace(line[i])) i++;
+    if (keyword === "note") {
+      if (i >= length || line[i] !== "(") return null;
+      i++;
+      while (i < length && isWhitespace(line[i])) i++;
+      const xStart = i;
+      while (i < length && isDigitOrDot(line[i])) i++;
+      if (i === xStart) return null;
+      const x = parseFloat(line.substring(xStart, i));
+      while (i < length && isWhitespace(line[i])) i++;
+      if (i >= length || line[i] !== ",") return null;
+      i++;
+      while (i < length && isWhitespace(line[i])) i++;
+      const yStart = i;
+      while (i < length && isDigitOrDot(line[i])) i++;
+      if (i === yStart) return null;
+      const y = parseFloat(line.substring(yStart, i));
+      while (i < length && isWhitespace(line[i])) i++;
+      if (i >= length || line[i] !== ")") return null;
+      i++;
+      while (i < length && isWhitespace(line[i])) i++;
+      const text = line.substring(i).trim();
+      return {
+        type: "note",
+        coordinates: [x, y],
+        text
+      };
+    }
+    if (keyword === "group") {
+      const components = line.substring(i).split(",").map((v) => v.trim()).filter((v) => v);
+      return components.length > 0 ? { type: "group", components } : null;
+    }
+    if (keyword === "inertia") {
+      const component = line.substring(i).trim();
+      return component ? { type: "inertia", component } : null;
+    }
+    if (keyword === "evolution") {
+      let indexOfSign = -1;
+      let signCharacter = null;
+      for (let j = i; j < length; j++) {
+        if (line[j] === "+" || line[j] === "-") {
+          if (j + 1 < length && (line[j + 1] === ">" || line[j + 1] === "-"))
+            continue;
+          indexOfSign = j;
+          signCharacter = line[j];
+          break;
+        }
+      }
+      if (indexOfSign === -1 || indexOfSign === i) return null;
+      const component = line.substring(i, indexOfSign).trim();
+      if (!component) return null;
+      let indexOfNumber = indexOfSign + 1;
+      while (indexOfNumber < length && isWhitespace(line[indexOfNumber]))
+        indexOfNumber++;
+      const startOfNumber = indexOfNumber;
+      while (indexOfNumber < length && isDigitOrDot(line[indexOfNumber]))
+        indexOfNumber++;
+      if (indexOfNumber === startOfNumber) return null;
+      return {
+        type: "evolution",
+        component,
+        value: (signCharacter === "+" ? 1 : -1) * parseFloat(line.substring(startOfNumber, indexOfNumber))
+      };
+    }
+    if (keyword === "i" || keyword === "ii" || keyword === "iii" || keyword === "iv") {
+      const startOfNumber = i;
+      while (i < length && isDigitOrDot(line[i])) i++;
+      if (i > startOfNumber) {
+        return {
+          type: "stage",
+          stage: keyword,
+          value: parseFloat(line.substring(startOfNumber, i))
+        };
+      }
+    }
+    return null;
+  }
+  function parseComponentOrDependency(line, length) {
+    const indexOfArrow = line.indexOf("->");
+    const indexOfDash = line.indexOf("--");
+    const indexOfParenthesis = line.indexOf("(");
+    if (indexOfArrow !== -1 && (indexOfParenthesis === -1 || indexOfArrow < indexOfParenthesis)) {
+      const from = line.substring(0, indexOfArrow).trim();
+      const to = line.substring(indexOfArrow + 2).trim();
+      if (from && to) {
+        return {
+          type: "dependency",
+          from,
+          to,
+          isDirected: true
+        };
+      }
+      return null;
+    }
+    if (indexOfDash !== -1 && (indexOfParenthesis === -1 || indexOfDash < indexOfParenthesis)) {
+      const from = line.substring(0, indexOfDash).trim();
+      const to = line.substring(indexOfDash + 2).trim();
+      if (from && to) {
+        return {
+          type: "dependency",
+          from,
+          to,
+          isDirected: false
+        };
+      }
+      return null;
+    }
+    if (indexOfParenthesis > 0) {
+      return parseComponent(line, indexOfParenthesis, length);
+    }
+    return null;
+  }
+  function parseComponent(line, indexOfParenthesis, length) {
+    const label = line.substring(0, indexOfParenthesis).trim();
+    if (!label) return null;
+    let i = indexOfParenthesis + 1;
+    while (i < length && isWhitespace(line[i])) i++;
+    const xStart = i;
+    while (i < length && isDigitOrDot(line[i])) i++;
+    if (i === xStart) return null;
+    const x = parseFloat(line.substring(xStart, i));
+    while (i < length && isWhitespace(line[i])) i++;
+    if (i >= length || line[i] !== ",") return null;
+    i++;
+    while (i < length && isWhitespace(line[i])) i++;
+    const yStart = i;
+    while (i < length && isDigitOrDot(line[i])) i++;
+    if (i === yStart) return null;
+    const y = parseFloat(line.substring(yStart, i));
+    while (i < length && isWhitespace(line[i])) i++;
+    if (i >= length || line[i] !== ")") return null;
+    i++;
+    let shape = "circle";
+    while (i < length && isWhitespace(line[i])) i++;
+    if (i < length && line[i] === "[") {
+      i++;
+      const shapeStart = i;
+      while (i < length && line[i] !== "]") i++;
+      if (i > shapeStart && i < length) {
+        shape = line.substring(shapeStart, i).trim().toLowerCase();
+      }
+    }
+    return {
+      type: "component",
+      label,
+      coordinates: [x, y],
+      shape
+    };
+  }
+  function isWhitespace(character) {
+    return character === " " || character === "	";
+  }
+  function isDigitOrDot(character) {
+    return character >= "0" && character <= "9" || character === ".";
+  }
+
+  // node_modules/.pnpm/wmap-renderer-canvas@1.0.1/node_modules/wmap-renderer-canvas/src/patterns.js
+  var patterns = {
+    stitch: [
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      0,
+      1
+    ],
+    shingles: [
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      0,
+      1,
+      1,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1
+    ],
+    shadowGrid: [
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      0,
+      0
+    ],
+    wicker: [
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      0,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      1,
+      0,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      0
+    ]
+  };
+  async function createPattern(ctx, patternData, pixelSize, fgColor, bgColor) {
+    const size = 8;
+    let patternCanvas;
+    const isNode = typeof window === "undefined";
+    if (isNode) {
+      const { createCanvas } = await Promise.resolve().then(() => __toESM(require_browser(), 1));
+      patternCanvas = createCanvas(size * pixelSize, size * pixelSize);
+    } else {
+      patternCanvas = window.document.createElement("canvas");
+      patternCanvas.width = size * pixelSize;
+      patternCanvas.height = size * pixelSize;
+    }
+    const patternCtx = patternCanvas.getContext("2d");
+    for (let y = 0; y < size; y++) {
+      for (let x = 0; x < size; x++) {
+        const value = patternData[y * size + x];
+        patternCtx.fillStyle = value === 0 ? fgColor : bgColor;
+        patternCtx.fillRect(
+          x * pixelSize,
+          y * pixelSize,
+          pixelSize,
+          pixelSize
+        );
+      }
+    }
+    return ctx.createPattern(patternCanvas, "repeat");
+  }
+
+  // node_modules/.pnpm/wmap-renderer-canvas@1.0.1/node_modules/wmap-renderer-canvas/src/utils.js
+  var internals = {
+    kDefaultStages: [25, 50, 75]
+  };
+  function percentToPixel(percentage, dimension) {
+    return percentage * dimension / 100;
+  }
+  function getStageValues(stageOverrides) {
+    const stages = [...internals.kDefaultStages];
+    if (stageOverrides && stageOverrides.length > 0) {
+      stageOverrides.forEach((override) => {
+        const index = { i: 0, ii: 1, iii: 2 }[override.stage];
+        if (index !== void 0) {
+          stages[index] = override.value;
+        }
+      });
+    }
+    return stages;
+  }
+  function createComponentMap(components, width, height) {
+    return components.reduce((map, current) => {
+      map[current.label.toLowerCase()] = [
+        percentToPixel(current.coordinates[0], width),
+        percentToPixel(current.coordinates[1], height)
+      ];
+      return map;
+    }, {});
+  }
+
+  // node_modules/.pnpm/wmap-renderer-canvas@1.0.1/node_modules/wmap-renderer-canvas/src/smart-label-positioning.js
+  function calculateOptimalLabelPosition(component, mapData, config, ctx, allLines, noteRects, inertiaRects) {
+    const { mapWidth, mapHeight, vertexWidth, vertexHeight } = config.theme.sizes;
+    const { family: fontFamily, vertexLabel: fontSize } = config.theme.fonts;
+    const vertexPixelPos = {
+      x: percentToPixel(component.coordinates[0], mapWidth),
+      y: percentToPixel(component.coordinates[1], mapHeight)
+    };
+    ctx.font = `${fontSize}px ${fontFamily}`;
+    const actualLabelSize = calculateLabelSize(component.label, ctx, config);
+    const candidatePositions = generateCandidatePositions(
+      vertexPixelPos,
+      { width: vertexWidth, height: vertexHeight },
+      actualLabelSize
+    );
+    const defaultPosition = candidatePositions[0];
+    const defaultRect = {
+      x: defaultPosition.x,
+      y: defaultPosition.y,
+      width: actualLabelSize.width,
+      height: actualLabelSize.height
+    };
+    if (countCollisions(defaultRect, allLines) === 0 && countNoteCollisions(defaultRect, noteRects) === 0 && countNoteCollisions(defaultRect, inertiaRects) === 0) {
+      return defaultPosition;
+    }
+    let bestPosition = defaultPosition;
+    let bestScore = Infinity;
+    for (let index = 0; index < candidatePositions.length; index++) {
+      const position = candidatePositions[index];
+      const labelRect = {
+        x: position.x,
+        y: position.y,
+        width: actualLabelSize.width,
+        height: actualLabelSize.height
+      };
+      const collisionCount = countCollisions(labelRect, allLines);
+      const noteCollisionCount = countNoteCollisions(labelRect, noteRects);
+      const inertiaCollisionCount = countNoteCollisions(
+        labelRect,
+        inertiaRects
+      );
+      const distance2 = Math.sqrt(
+        Math.pow(position.x - (vertexPixelPos.x + vertexWidth / 2), 2) + Math.pow(position.y - (vertexPixelPos.y + vertexHeight / 2), 2)
+      );
+      const ownershipPenalty = calculateOwnershipPenalty(
+        labelRect,
+        component,
+        mapData.components,
+        config
+      );
+      const score = collisionCount * 100 + noteCollisionCount * 500 + inertiaCollisionCount * 300 + distance2 * 0.5 + index * 0.1 + ownershipPenalty;
+      if (score < bestScore) {
+        bestScore = score;
+        bestPosition = position;
+      }
+    }
+    return bestPosition;
+  }
+  function calculateLabelSize(text, ctx, config) {
+    const cleanText = text.replace(/\\n/g, "\n");
+    const lines = cleanText.split("\n");
+    const lineHeight = config.theme.lineHeights.vertexLabel;
+    let maxWidth = 0;
+    let totalHeight = 0;
+    for (const line of lines) {
+      const metrics = ctx.measureText(line);
+      maxWidth = Math.max(maxWidth, metrics.width);
+      totalHeight += lineHeight;
+    }
+    return {
+      width: Math.ceil(maxWidth) + 4,
+      height: Math.ceil(totalHeight) + 2
+    };
+  }
+  function generateCandidatePositions(vertexPixelPos, vertexSize, labelSize) {
+    const padding = 5;
+    return [
+      // Right
+      {
+        x: vertexPixelPos.x + vertexSize.width + padding,
+        y: vertexPixelPos.y + (vertexSize.height - labelSize.height) / 2
+      },
+      // Left
+      {
+        x: vertexPixelPos.x - labelSize.width - padding,
+        y: vertexPixelPos.y + (vertexSize.height - labelSize.height) / 2
+      },
+      // Top
+      {
+        x: vertexPixelPos.x + (vertexSize.width - labelSize.width) / 2,
+        y: vertexPixelPos.y - labelSize.height - padding
+      },
+      // Bottom
+      {
+        x: vertexPixelPos.x + (vertexSize.width - labelSize.width) / 2,
+        y: vertexPixelPos.y + vertexSize.height + padding
+      },
+      // Top-right
+      {
+        x: vertexPixelPos.x + vertexSize.width + padding,
+        y: vertexPixelPos.y - labelSize.height - padding
+      },
+      // Top-left
+      {
+        x: vertexPixelPos.x - labelSize.width - padding,
+        y: vertexPixelPos.y - labelSize.height - padding
+      },
+      // Bottom-right
+      {
+        x: vertexPixelPos.x + vertexSize.width + padding,
+        y: vertexPixelPos.y + vertexSize.height + padding
+      },
+      // Bottom-left
+      {
+        x: vertexPixelPos.x - labelSize.width - padding,
+        y: vertexPixelPos.y + vertexSize.height + padding
+      }
+    ];
+  }
+  function collectAllLines(mapData, config, componentMap) {
+    const { mapWidth, mapHeight, vertexWidth, vertexHeight } = config.theme.sizes;
+    const lines = [];
+    if (mapData.dependencies) {
+      mapData.dependencies.forEach((edge) => {
+        const originCoords = componentMap[edge.origin];
+        const destCoords = componentMap[edge.destination];
+        if (!originCoords || !destCoords) return;
+        const origin = {
+          x: originCoords[0],
+          mapWidth,
+          y: originCoords[1],
+          mapHeight
+        };
+        const destination = {
+          x: destCoords[0],
+          mapWidth,
+          y: destCoords[1],
+          mapHeight
+        };
+        const slope = (destination.y - origin.y) / (destination.x - origin.x);
+        const angle = Math.atan(slope);
+        const multiplier = slope < 0 ? -1 : 1;
+        const offsetOrigin = {
+          x: origin.x + multiplier * (vertexWidth / 2) * Math.cos(angle),
+          y: origin.y + multiplier * (vertexHeight / 2) * Math.sin(angle)
+        };
+        const offsetDestination = {
+          x: destination.x - multiplier * (vertexWidth / 2) * Math.cos(angle),
+          y: destination.y - multiplier * (vertexHeight / 2) * Math.sin(angle)
+        };
+        const adjustedOrigin = {
+          x: offsetOrigin.x + vertexWidth / 2,
+          y: offsetOrigin.y + vertexHeight / 2
+        };
+        const adjustedDestination = {
+          x: offsetDestination.x + vertexWidth / 2,
+          y: offsetDestination.y + vertexHeight / 2
+        };
+        lines.push({ start: adjustedOrigin, end: adjustedDestination });
+      });
+    }
+    if (mapData.evolutions) {
+      mapData.evolutions.forEach((evolution) => {
+        const coords = componentMap[evolution.component];
+        if (!coords) return;
+        const originX = coords[0];
+        const originY = coords[1];
+        const destX = evolution.value;
+        const origin = {
+          x: originX,
+          mapWidth,
+          y: originY,
+          mapHeight
+        };
+        const destination = {
+          x: destX,
+          mapWidth,
+          y: originY,
+          mapHeight
+        };
+        const multiplier = destX > originX ? 1 : -1;
+        const offsetOrigin = {
+          x: origin.x + multiplier * (vertexWidth / 2),
+          y: origin.y
+        };
+        const offsetDestination = {
+          x: destination.x - multiplier * (vertexWidth / 2),
+          y: destination.y
+        };
+        const adjustedOrigin = {
+          x: offsetOrigin.x + vertexWidth / 2,
+          y: offsetOrigin.y + vertexHeight / 2
+        };
+        const adjustedDestination = {
+          x: offsetDestination.x + vertexWidth / 2,
+          y: offsetDestination.y + vertexHeight / 2
+        };
+        lines.push({ start: adjustedOrigin, end: adjustedDestination });
+      });
+    }
+    lines.push(
+      { start: { x: 0, y: 0 }, end: { x: 0, y: mapHeight } },
+      { start: { x: 0, y: mapHeight }, end: { x: mapWidth, y: mapHeight } }
+    );
+    return lines;
+  }
+  function collectNoteRects(mapData, config, ctx) {
+    if (!mapData.notes) return [];
+    const { mapWidth, mapHeight } = config.theme.sizes;
+    return mapData.notes.map((note) => {
+      const notePixelPos = {
+        x: percentToPixel(note.coordinates[0], mapWidth),
+        y: percentToPixel(note.coordinates[1], mapHeight)
+      };
+      const noteSize = calculateLabelSize(note.text, ctx, config);
+      return {
+        x: notePixelPos.x,
+        y: notePixelPos.y,
+        width: noteSize.width,
+        height: noteSize.height
+      };
+    });
+  }
+  function collectInertiaRects(mapData, config, componentMap) {
+    if (!mapData.inertias) return [];
+    const { vertexWidth, vertexHeight } = config.theme.sizes;
+    return mapData.inertias.map((inertia) => {
+      if (!inertia.component) return null;
+      const coordinates = componentMap[inertia.component.toLowerCase()];
+      if (!coordinates) return null;
+      const x = coordinates[0] + 3 * vertexWidth;
+      const y = coordinates[1] - vertexHeight * 2 / 3;
+      const rectWidth = vertexWidth / 2;
+      const rectHeight = vertexHeight * 2;
+      return {
+        x,
+        y,
+        width: rectWidth,
+        height: rectHeight
+      };
+    }).filter((rect) => rect !== null);
+  }
+  function countCollisions(labelRect, lines) {
+    let collisions = 0;
+    for (const line of lines) {
+      if (lineIntersectsRect(line, labelRect)) {
+        collisions++;
+      }
+    }
+    return collisions;
+  }
+  function countNoteCollisions(labelRect, noteRects) {
+    let collisions = 0;
+    for (const noteRect of noteRects) {
+      if (rectsIntersect(labelRect, noteRect)) {
+        collisions++;
+      }
+    }
+    return collisions;
+  }
+  function rectsIntersect(rect1, rect2) {
+    return !(rect1.x + rect1.width < rect2.x || rect2.x + rect2.width < rect1.x || rect1.y + rect1.height < rect2.y || rect2.y + rect2.height < rect1.y);
+  }
+  function lineIntersectsRect(line, rect) {
+    const rectLines = [
+      {
+        start: { x: rect.x, y: rect.y },
+        end: { x: rect.x + rect.width, y: rect.y }
+      },
+      {
+        start: { x: rect.x + rect.width, y: rect.y },
+        end: { x: rect.x + rect.width, y: rect.y + rect.height }
+      },
+      {
+        start: { x: rect.x + rect.width, y: rect.y + rect.height },
+        end: { x: rect.x, y: rect.y + rect.height }
+      },
+      {
+        start: { x: rect.x, y: rect.y + rect.height },
+        end: { x: rect.x, y: rect.y }
+      }
+    ];
+    for (const rectLine of rectLines) {
+      if (linesIntersect(line, rectLine)) {
+        return true;
+      }
+    }
+    return pointInRect(line.start, rect) || pointInRect(line.end, rect);
+  }
+  function pointInRect(point2, rect) {
+    return point2.x >= rect.x && point2.x <= rect.x + rect.width && point2.y >= rect.y && point2.y <= rect.y + rect.height;
+  }
+  function linesIntersect(line1, line2) {
+    const x1 = line1.start.x;
+    const y1 = line1.start.y;
+    const x2 = line1.end.x;
+    const y2 = line1.end.y;
+    const x3 = line2.start.x;
+    const y3 = line2.start.y;
+    const x4 = line2.end.x;
+    const y4 = line2.end.y;
+    const denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+    if (Math.abs(denom) < 1e-10) {
+      return false;
+    }
+    const t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / denom;
+    const u = -((x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3)) / denom;
+    return t >= 0 && t <= 1 && u >= 0 && u <= 1;
+  }
+  function calculateOwnershipPenalty(labelRect, ownComponent, allComponents, config) {
+    if (allComponents.length === 0) return 0;
+    const { mapWidth, mapHeight, vertexWidth, vertexHeight } = config.theme.sizes;
+    const labelCenter = {
+      x: labelRect.x + labelRect.width / 2,
+      y: labelRect.y + labelRect.height / 2
+    };
+    const ownVertexPixelPos = {
+      x: percentToPixel(ownComponent.coordinates[0], mapWidth),
+      y: percentToPixel(ownComponent.coordinates[1], mapHeight)
+    };
+    const ownVertexCenter = {
+      x: ownVertexPixelPos.x + vertexWidth / 2,
+      y: ownVertexPixelPos.y + vertexHeight / 2
+    };
+    const distanceToOwnVertex = Math.sqrt(
+      Math.pow(labelCenter.x - ownVertexCenter.x, 2) + Math.pow(labelCenter.y - ownVertexCenter.y, 2)
+    );
+    for (const otherComponent of allComponents) {
+      if (otherComponent === ownComponent) continue;
+      const otherVertexPixelPos = {
+        x: percentToPixel(otherComponent.coordinates[0], mapWidth),
+        y: percentToPixel(otherComponent.coordinates[1], mapHeight)
+      };
+      const otherVertexCenter = {
+        x: otherVertexPixelPos.x + vertexWidth / 2,
+        y: otherVertexPixelPos.y + vertexHeight / 2
+      };
+      const distanceToOtherVertex = Math.sqrt(
+        Math.pow(labelCenter.x - otherVertexCenter.x, 2) + Math.pow(labelCenter.y - otherVertexCenter.y, 2)
+      );
+      if (distanceToOtherVertex < distanceToOwnVertex) {
+        return 50;
+      }
+    }
+    return 0;
+  }
+
+  // node_modules/.pnpm/@turf+helpers@7.3.1/node_modules/@turf/helpers/dist/esm/index.js
+  var earthRadius = 63710088e-1;
+  var factors = {
+    centimeters: earthRadius * 100,
+    centimetres: earthRadius * 100,
+    degrees: 360 / (2 * Math.PI),
+    feet: earthRadius * 3.28084,
+    inches: earthRadius * 39.37,
+    kilometers: earthRadius / 1e3,
+    kilometres: earthRadius / 1e3,
+    meters: earthRadius,
+    metres: earthRadius,
+    miles: earthRadius / 1609.344,
+    millimeters: earthRadius * 1e3,
+    millimetres: earthRadius * 1e3,
+    nauticalmiles: earthRadius / 1852,
+    radians: 1,
+    yards: earthRadius * 1.0936
+  };
+  function feature(geom, properties, options = {}) {
+    const feat = { type: "Feature" };
+    if (options.id === 0 || options.id) {
+      feat.id = options.id;
+    }
+    if (options.bbox) {
+      feat.bbox = options.bbox;
+    }
+    feat.properties = properties || {};
+    feat.geometry = geom;
+    return feat;
+  }
+  function point(coordinates, properties, options = {}) {
+    if (!coordinates) {
+      throw new Error("coordinates is required");
+    }
+    if (!Array.isArray(coordinates)) {
+      throw new Error("coordinates must be an Array");
+    }
+    if (coordinates.length < 2) {
+      throw new Error("coordinates must be at least 2 numbers long");
+    }
+    if (!isNumber(coordinates[0]) || !isNumber(coordinates[1])) {
+      throw new Error("coordinates must contain numbers");
+    }
+    const geom = {
+      type: "Point",
+      coordinates
+    };
+    return feature(geom, properties, options);
+  }
+  function polygon(coordinates, properties, options = {}) {
+    for (const ring of coordinates) {
+      if (ring.length < 4) {
+        throw new Error(
+          "Each LinearRing of a Polygon must have 4 or more Positions."
+        );
+      }
+      if (ring[ring.length - 1].length !== ring[0].length) {
+        throw new Error("First and last Position are not equivalent.");
+      }
+      for (let j = 0; j < ring[ring.length - 1].length; j++) {
+        if (ring[ring.length - 1][j] !== ring[0][j]) {
+          throw new Error("First and last Position are not equivalent.");
+        }
+      }
+    }
+    const geom = {
+      type: "Polygon",
+      coordinates
+    };
+    return feature(geom, properties, options);
+  }
+  function lineString(coordinates, properties, options = {}) {
+    if (coordinates.length < 2) {
+      throw new Error("coordinates must be an array of two or more positions");
+    }
+    const geom = {
+      type: "LineString",
+      coordinates
+    };
+    return feature(geom, properties, options);
+  }
+  function featureCollection(features, options = {}) {
+    const fc = { type: "FeatureCollection" };
+    if (options.id) {
+      fc.id = options.id;
+    }
+    if (options.bbox) {
+      fc.bbox = options.bbox;
+    }
+    fc.features = features;
+    return fc;
+  }
+  function multiLineString(coordinates, properties, options = {}) {
+    const geom = {
+      type: "MultiLineString",
+      coordinates
+    };
+    return feature(geom, properties, options);
+  }
+  function geometryCollection(geometries, properties, options = {}) {
+    const geom = {
+      type: "GeometryCollection",
+      geometries
+    };
+    return feature(geom, properties, options);
+  }
+  function radiansToLength(radians, units = "kilometers") {
+    const factor = factors[units];
+    if (!factor) {
+      throw new Error(units + " units is invalid");
+    }
+    return radians * factor;
+  }
+  function degreesToRadians(degrees) {
+    const normalisedDegrees = degrees % 360;
+    return normalisedDegrees * Math.PI / 180;
+  }
+  function isNumber(num) {
+    return !isNaN(num) && num !== null && !Array.isArray(num);
+  }
+  function isObject(input) {
+    return input !== null && typeof input === "object" && !Array.isArray(input);
+  }
+
+  // node_modules/.pnpm/@turf+invariant@7.3.1/node_modules/@turf/invariant/dist/esm/index.js
+  function getCoord(coord) {
+    if (!coord) {
+      throw new Error("coord is required");
+    }
+    if (!Array.isArray(coord)) {
+      if (coord.type === "Feature" && coord.geometry !== null && coord.geometry.type === "Point") {
+        return [...coord.geometry.coordinates];
+      }
+      if (coord.type === "Point") {
+        return [...coord.coordinates];
+      }
+    }
+    if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
+      return [...coord];
+    }
+    throw new Error("coord must be GeoJSON Point or an Array of numbers");
+  }
+  function getType(geojson, _name) {
+    if (geojson.type === "FeatureCollection") {
+      return "FeatureCollection";
+    }
+    if (geojson.type === "GeometryCollection") {
+      return "GeometryCollection";
+    }
+    if (geojson.type === "Feature" && geojson.geometry !== null) {
+      return geojson.geometry.type;
+    }
+    return geojson.type;
+  }
+
+  // node_modules/.pnpm/@turf+distance@7.3.1/node_modules/@turf/distance/dist/esm/index.js
+  function distance(from, to, options = {}) {
+    var coordinates1 = getCoord(from);
+    var coordinates2 = getCoord(to);
+    var dLat = degreesToRadians(coordinates2[1] - coordinates1[1]);
+    var dLon = degreesToRadians(coordinates2[0] - coordinates1[0]);
+    var lat1 = degreesToRadians(coordinates1[1]);
+    var lat2 = degreesToRadians(coordinates2[1]);
+    var a = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1) * Math.cos(lat2);
+    return radiansToLength(
+      2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)),
+      options.units
+    );
+  }
+
+  // node_modules/.pnpm/@turf+meta@7.3.1/node_modules/@turf/meta/dist/esm/index.js
+  function featureEach(geojson, callback) {
+    if (geojson.type === "Feature") {
+      callback(geojson, 0);
+    } else if (geojson.type === "FeatureCollection") {
+      for (var i = 0; i < geojson.features.length; i++) {
+        if (callback(geojson.features[i], i) === false) break;
+      }
+    }
+  }
+  function geomEach(geojson, callback) {
+    var i, j, g, geometry, stopG, geometryMaybeCollection, isGeometryCollection, featureProperties, featureBBox, featureId, featureIndex = 0, isFeatureCollection = geojson.type === "FeatureCollection", isFeature = geojson.type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+    for (i = 0; i < stop; i++) {
+      geometryMaybeCollection = isFeatureCollection ? geojson.features[i].geometry : isFeature ? geojson.geometry : geojson;
+      featureProperties = isFeatureCollection ? geojson.features[i].properties : isFeature ? geojson.properties : {};
+      featureBBox = isFeatureCollection ? geojson.features[i].bbox : isFeature ? geojson.bbox : void 0;
+      featureId = isFeatureCollection ? geojson.features[i].id : isFeature ? geojson.id : void 0;
+      isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+      stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+      for (g = 0; g < stopG; g++) {
+        geometry = isGeometryCollection ? geometryMaybeCollection.geometries[g] : geometryMaybeCollection;
+        if (geometry === null) {
+          if (callback(
+            null,
+            featureIndex,
+            featureProperties,
+            featureBBox,
+            featureId
+          ) === false)
+            return false;
+          continue;
+        }
+        switch (geometry.type) {
+          case "Point":
+          case "LineString":
+          case "MultiPoint":
+          case "Polygon":
+          case "MultiLineString":
+          case "MultiPolygon": {
+            if (callback(
+              geometry,
+              featureIndex,
+              featureProperties,
+              featureBBox,
+              featureId
+            ) === false)
+              return false;
+            break;
+          }
+          case "GeometryCollection": {
+            for (j = 0; j < geometry.geometries.length; j++) {
+              if (callback(
+                geometry.geometries[j],
+                featureIndex,
+                featureProperties,
+                featureBBox,
+                featureId
+              ) === false)
+                return false;
+            }
+            break;
+          }
+          default:
+            throw new Error("Unknown Geometry Type");
+        }
+      }
+      featureIndex++;
+    }
+  }
+  function flattenEach(geojson, callback) {
+    geomEach(geojson, function(geometry, featureIndex, properties, bbox, id) {
+      var type = geometry === null ? null : geometry.type;
+      switch (type) {
+        case null:
+        case "Point":
+        case "LineString":
+        case "Polygon":
+          if (callback(
+            feature(geometry, properties, { bbox, id }),
+            featureIndex,
+            0
+          ) === false)
+            return false;
+          return;
+      }
+      var geomType;
+      switch (type) {
+        case "MultiPoint":
+          geomType = "Point";
+          break;
+        case "MultiLineString":
+          geomType = "LineString";
+          break;
+        case "MultiPolygon":
+          geomType = "Polygon";
+          break;
+      }
+      for (var multiFeatureIndex = 0; multiFeatureIndex < geometry.coordinates.length; multiFeatureIndex++) {
+        var coordinate = geometry.coordinates[multiFeatureIndex];
+        var geom = {
+          type: geomType,
+          coordinates: coordinate
+        };
+        if (callback(feature(geom, properties), featureIndex, multiFeatureIndex) === false)
+          return false;
+      }
+    });
+  }
+  function lineEach(geojson, callback) {
+    if (!geojson) throw new Error("geojson is required");
+    flattenEach(geojson, function(feature2, featureIndex, multiFeatureIndex) {
+      if (feature2.geometry === null) return;
+      var type = feature2.geometry.type;
+      var coords = feature2.geometry.coordinates;
+      switch (type) {
+        case "LineString":
+          if (callback(feature2, featureIndex, multiFeatureIndex, 0, 0) === false)
+            return false;
+          break;
+        case "Polygon":
+          for (var geometryIndex = 0; geometryIndex < coords.length; geometryIndex++) {
+            if (callback(
+              lineString(coords[geometryIndex], feature2.properties),
+              featureIndex,
+              multiFeatureIndex,
+              geometryIndex
+            ) === false)
+              return false;
+          }
+          break;
+      }
+    });
+  }
+  function lineReduce(geojson, callback, initialValue) {
+    var previousValue = initialValue;
+    lineEach(
+      geojson,
+      function(currentLine, featureIndex, multiFeatureIndex, geometryIndex) {
+        if (featureIndex === 0 && initialValue === void 0)
+          previousValue = currentLine;
+        else
+          previousValue = callback(
+            previousValue,
+            currentLine,
+            featureIndex,
+            multiFeatureIndex,
+            geometryIndex
+          );
+      }
+    );
+    return previousValue;
+  }
+
+  // node_modules/.pnpm/@turf+tin@7.3.1/node_modules/@turf/tin/dist/esm/index.js
+  function tin(points, z) {
+    let isPointZ = false;
+    return featureCollection(
+      triangulate(
+        points.features.map((p) => {
+          const point2 = {
+            x: p.geometry.coordinates[0],
+            y: p.geometry.coordinates[1]
+          };
+          if (z) {
+            point2.z = p.properties[z];
+          } else if (p.geometry.coordinates.length === 3) {
+            isPointZ = true;
+            point2.z = p.geometry.coordinates[2];
+          }
+          return point2;
+        })
+      ).map((triangle) => {
+        const a = [triangle.a.x, triangle.a.y];
+        const b = [triangle.b.x, triangle.b.y];
+        const c = [triangle.c.x, triangle.c.y];
+        let properties = {};
+        if (isPointZ) {
+          a.push(triangle.a.z);
+          b.push(triangle.b.z);
+          c.push(triangle.c.z);
+        } else {
+          properties = {
+            a: triangle.a.z,
+            b: triangle.b.z,
+            c: triangle.c.z
+          };
+        }
+        return polygon([[a, b, c, a]], properties);
+      })
+    );
+  }
+  var Triangle = class {
+    constructor(a, b, c) {
+      this.a = a;
+      this.b = b;
+      this.c = c;
+      const A = b.x - a.x;
+      const B = b.y - a.y;
+      const C = c.x - a.x;
+      const D = c.y - a.y;
+      const E = A * (a.x + b.x) + B * (a.y + b.y);
+      const F = C * (a.x + c.x) + D * (a.y + c.y);
+      const G = 2 * (A * (c.y - b.y) - B * (c.x - b.x));
+      let dx;
+      let dy;
+      this.x = (D * E - B * F) / G;
+      this.y = (A * F - C * E) / G;
+      dx = this.x - a.x;
+      dy = this.y - a.y;
+      this.r = dx * dx + dy * dy;
+    }
+  };
+  function byX(a, b) {
+    return b.x - a.x;
+  }
+  function dedup(edges) {
+    let j = edges.length;
+    let a;
+    let b;
+    let i;
+    let m;
+    let n;
+    outer: while (j) {
+      b = edges[--j];
+      a = edges[--j];
+      i = j;
+      while (i) {
+        n = edges[--i];
+        m = edges[--i];
+        if (a === m && b === n || a === n && b === m) {
+          edges.splice(j, 2);
+          edges.splice(i, 2);
+          j -= 2;
+          continue outer;
+        }
+      }
+    }
+  }
+  function triangulate(vertices) {
+    if (vertices.length < 3) {
+      return [];
+    }
+    vertices.sort(byX);
+    let i = vertices.length - 1;
+    const xmin = vertices[i].x;
+    const xmax = vertices[0].x;
+    let ymin = vertices[i].y;
+    let ymax = ymin;
+    const epsilon = 1e-12;
+    let a;
+    let b;
+    let c;
+    let A;
+    let B;
+    let G;
+    while (i--) {
+      if (vertices[i].y < ymin) {
+        ymin = vertices[i].y;
+      }
+      if (vertices[i].y > ymax) {
+        ymax = vertices[i].y;
+      }
+    }
+    let dx = xmax - xmin;
+    let dy = ymax - ymin;
+    const dmax = dx > dy ? dx : dy;
+    const xmid = (xmax + xmin) * 0.5;
+    const ymid = (ymax + ymin) * 0.5;
+    const open = [
+      new Triangle(
+        {
+          __sentinel: true,
+          x: xmid - 20 * dmax,
+          y: ymid - dmax
+        },
+        {
+          __sentinel: true,
+          x: xmid,
+          y: ymid + 20 * dmax
+        },
+        {
+          __sentinel: true,
+          x: xmid + 20 * dmax,
+          y: ymid - dmax
+        }
+      )
+    ];
+    const closed = [];
+    const edges = [];
+    let j;
+    i = vertices.length;
+    while (i--) {
+      edges.length = 0;
+      j = open.length;
+      while (j--) {
+        dx = vertices[i].x - open[j].x;
+        if (dx > 0 && dx * dx > open[j].r) {
+          closed.push(open[j]);
+          open.splice(j, 1);
+          continue;
+        }
+        dy = vertices[i].y - open[j].y;
+        if (dx * dx + dy * dy > open[j].r) {
+          continue;
+        }
+        edges.push(
+          open[j].a,
+          open[j].b,
+          open[j].b,
+          open[j].c,
+          open[j].c,
+          open[j].a
+        );
+        open.splice(j, 1);
+      }
+      dedup(edges);
+      j = edges.length;
+      while (j) {
+        b = edges[--j];
+        a = edges[--j];
+        c = vertices[i];
+        A = b.x - a.x;
+        B = b.y - a.y;
+        G = 2 * (A * (c.y - b.y) - B * (c.x - b.x));
+        if (Math.abs(G) > epsilon) {
+          open.push(new Triangle(a, b, c));
+        }
+      }
+    }
+    Array.prototype.push.apply(closed, open);
+    i = closed.length;
+    while (i--) {
+      if (closed[i].a.__sentinel || closed[i].b.__sentinel || closed[i].c.__sentinel) {
+        closed.splice(i, 1);
+      }
+    }
+    return closed;
+  }
+
+  // node_modules/.pnpm/@turf+clone@7.3.1/node_modules/@turf/clone/dist/esm/index.js
+  function clone(geojson) {
+    if (!geojson) {
+      throw new Error("geojson is required");
+    }
+    switch (geojson.type) {
+      case "Feature":
+        return cloneFeature(geojson);
+      case "FeatureCollection":
+        return cloneFeatureCollection(geojson);
+      case "Point":
+      case "LineString":
+      case "Polygon":
+      case "MultiPoint":
+      case "MultiLineString":
+      case "MultiPolygon":
+      case "GeometryCollection":
+        return cloneGeometry(geojson);
+      default:
+        throw new Error("unknown GeoJSON type");
+    }
+  }
+  function cloneFeature(geojson) {
+    const cloned = { type: "Feature" };
+    Object.keys(geojson).forEach((key) => {
+      switch (key) {
+        case "type":
+        case "properties":
+        case "geometry":
+          return;
+        default:
+          cloned[key] = geojson[key];
+      }
+    });
+    cloned.properties = cloneProperties(geojson.properties);
+    if (geojson.geometry == null) {
+      cloned.geometry = null;
+    } else {
+      cloned.geometry = cloneGeometry(geojson.geometry);
+    }
+    return cloned;
+  }
+  function cloneProperties(properties) {
+    const cloned = {};
+    if (!properties) {
+      return cloned;
+    }
+    Object.keys(properties).forEach((key) => {
+      const value = properties[key];
+      if (typeof value === "object") {
+        if (value === null) {
+          cloned[key] = null;
+        } else if (Array.isArray(value)) {
+          cloned[key] = value.map((item) => {
+            return item;
+          });
+        } else {
+          cloned[key] = cloneProperties(value);
+        }
+      } else {
+        cloned[key] = value;
+      }
+    });
+    return cloned;
+  }
+  function cloneFeatureCollection(geojson) {
+    const cloned = { type: "FeatureCollection" };
+    Object.keys(geojson).forEach((key) => {
+      switch (key) {
+        case "type":
+        case "features":
+          return;
+        default:
+          cloned[key] = geojson[key];
+      }
+    });
+    cloned.features = geojson.features.map((feature2) => {
+      return cloneFeature(feature2);
+    });
+    return cloned;
+  }
+  function cloneGeometry(geometry) {
+    const geom = { type: geometry.type };
+    if (geometry.bbox) {
+      geom.bbox = geometry.bbox;
+    }
+    if (geometry.type === "GeometryCollection") {
+      geom.geometries = geometry.geometries.map((g) => {
+        return cloneGeometry(g);
+      });
+      return geom;
+    }
+    geom.coordinates = deepSlice(geometry.coordinates);
+    return geom;
+  }
+  function deepSlice(coords) {
+    const cloned = coords;
+    if (typeof cloned[0] !== "object") {
+      return cloned.slice();
+    }
+    return cloned.map((coord) => {
+      return deepSlice(coord);
+    });
+  }
+
+  // node_modules/.pnpm/topojson-client@3.1.0/node_modules/topojson-client/src/identity.js
+  function identity_default(x) {
+    return x;
+  }
+
+  // node_modules/.pnpm/topojson-client@3.1.0/node_modules/topojson-client/src/transform.js
+  function transform_default(transform) {
+    if (transform == null) return identity_default;
+    var x0, y0, kx = transform.scale[0], ky = transform.scale[1], dx = transform.translate[0], dy = transform.translate[1];
+    return function(input, i) {
+      if (!i) x0 = y0 = 0;
+      var j = 2, n = input.length, output = new Array(n);
+      output[0] = (x0 += input[0]) * kx + dx;
+      output[1] = (y0 += input[1]) * ky + dy;
+      while (j < n) output[j] = input[j], ++j;
+      return output;
+    };
+  }
+
+  // node_modules/.pnpm/topojson-client@3.1.0/node_modules/topojson-client/src/reverse.js
+  function reverse_default(array, n) {
+    var t, j = array.length, i = j - n;
+    while (i < --j) t = array[i], array[i++] = array[j], array[j] = t;
+  }
+
+  // node_modules/.pnpm/topojson-client@3.1.0/node_modules/topojson-client/src/feature.js
+  function object(topology, o) {
+    var transformPoint = transform_default(topology.transform), arcs = topology.arcs;
+    function arc(i, points) {
+      if (points.length) points.pop();
+      for (var a = arcs[i < 0 ? ~i : i], k = 0, n = a.length; k < n; ++k) {
+        points.push(transformPoint(a[k], k));
+      }
+      if (i < 0) reverse_default(points, n);
+    }
+    function point2(p) {
+      return transformPoint(p);
+    }
+    function line(arcs2) {
+      var points = [];
+      for (var i = 0, n = arcs2.length; i < n; ++i) arc(arcs2[i], points);
+      if (points.length < 2) points.push(points[0]);
+      return points;
+    }
+    function ring(arcs2) {
+      var points = line(arcs2);
+      while (points.length < 4) points.push(points[0]);
+      return points;
+    }
+    function polygon2(arcs2) {
+      return arcs2.map(ring);
+    }
+    function geometry(o2) {
+      var type = o2.type, coordinates;
+      switch (type) {
+        case "GeometryCollection":
+          return { type, geometries: o2.geometries.map(geometry) };
+        case "Point":
+          coordinates = point2(o2.coordinates);
+          break;
+        case "MultiPoint":
+          coordinates = o2.coordinates.map(point2);
+          break;
+        case "LineString":
+          coordinates = line(o2.arcs);
+          break;
+        case "MultiLineString":
+          coordinates = o2.arcs.map(line);
+          break;
+        case "Polygon":
+          coordinates = polygon2(o2.arcs);
+          break;
+        case "MultiPolygon":
+          coordinates = o2.arcs.map(polygon2);
+          break;
+        default:
+          return null;
+      }
+      return { type, coordinates };
+    }
+    return geometry(o);
+  }
+
+  // node_modules/.pnpm/topojson-client@3.1.0/node_modules/topojson-client/src/stitch.js
+  function stitch_default(topology, arcs) {
+    var stitchedArcs = {}, fragmentByStart = {}, fragmentByEnd = {}, fragments = [], emptyIndex = -1;
+    arcs.forEach(function(i, j) {
+      var arc = topology.arcs[i < 0 ? ~i : i], t;
+      if (arc.length < 3 && !arc[1][0] && !arc[1][1]) {
+        t = arcs[++emptyIndex], arcs[emptyIndex] = i, arcs[j] = t;
+      }
+    });
+    arcs.forEach(function(i) {
+      var e = ends(i), start = e[0], end = e[1], f, g;
+      if (f = fragmentByEnd[start]) {
+        delete fragmentByEnd[f.end];
+        f.push(i);
+        f.end = end;
+        if (g = fragmentByStart[end]) {
+          delete fragmentByStart[g.start];
+          var fg = g === f ? f : f.concat(g);
+          fragmentByStart[fg.start = f.start] = fragmentByEnd[fg.end = g.end] = fg;
+        } else {
+          fragmentByStart[f.start] = fragmentByEnd[f.end] = f;
+        }
+      } else if (f = fragmentByStart[end]) {
+        delete fragmentByStart[f.start];
+        f.unshift(i);
+        f.start = start;
+        if (g = fragmentByEnd[start]) {
+          delete fragmentByEnd[g.end];
+          var gf = g === f ? f : g.concat(f);
+          fragmentByStart[gf.start = g.start] = fragmentByEnd[gf.end = f.end] = gf;
+        } else {
+          fragmentByStart[f.start] = fragmentByEnd[f.end] = f;
+        }
+      } else {
+        f = [i];
+        fragmentByStart[f.start = start] = fragmentByEnd[f.end = end] = f;
+      }
+    });
+    function ends(i) {
+      var arc = topology.arcs[i < 0 ? ~i : i], p0 = arc[0], p1;
+      if (topology.transform) p1 = [0, 0], arc.forEach(function(dp) {
+        p1[0] += dp[0], p1[1] += dp[1];
+      });
+      else p1 = arc[arc.length - 1];
+      return i < 0 ? [p1, p0] : [p0, p1];
+    }
+    function flush(fragmentByEnd2, fragmentByStart2) {
+      for (var k in fragmentByEnd2) {
+        var f = fragmentByEnd2[k];
+        delete fragmentByStart2[f.start];
+        delete f.start;
+        delete f.end;
+        f.forEach(function(i) {
+          stitchedArcs[i < 0 ? ~i : i] = 1;
+        });
+        fragments.push(f);
+      }
+    }
+    flush(fragmentByEnd, fragmentByStart);
+    flush(fragmentByStart, fragmentByEnd);
+    arcs.forEach(function(i) {
+      if (!stitchedArcs[i < 0 ? ~i : i]) fragments.push([i]);
+    });
+    return fragments;
+  }
+
+  // node_modules/.pnpm/topojson-client@3.1.0/node_modules/topojson-client/src/merge.js
+  function planarRingArea(ring) {
+    var i = -1, n = ring.length, a, b = ring[n - 1], area = 0;
+    while (++i < n) a = b, b = ring[i], area += a[0] * b[1] - a[1] * b[0];
+    return Math.abs(area);
+  }
+  function merge_default(topology) {
+    return object(topology, mergeArcs.apply(this, arguments));
+  }
+  function mergeArcs(topology, objects) {
+    var polygonsByArc = {}, polygons = [], groups = [];
+    objects.forEach(geometry);
+    function geometry(o) {
+      switch (o.type) {
+        case "GeometryCollection":
+          o.geometries.forEach(geometry);
+          break;
+        case "Polygon":
+          extract(o.arcs);
+          break;
+        case "MultiPolygon":
+          o.arcs.forEach(extract);
+          break;
+      }
+    }
+    function extract(polygon2) {
+      polygon2.forEach(function(ring) {
+        ring.forEach(function(arc) {
+          (polygonsByArc[arc = arc < 0 ? ~arc : arc] || (polygonsByArc[arc] = [])).push(polygon2);
+        });
+      });
+      polygons.push(polygon2);
+    }
+    function area(ring) {
+      return planarRingArea(object(topology, { type: "Polygon", arcs: [ring] }).coordinates[0]);
+    }
+    polygons.forEach(function(polygon2) {
+      if (!polygon2._) {
+        var group = [], neighbors = [polygon2];
+        polygon2._ = 1;
+        groups.push(group);
+        while (polygon2 = neighbors.pop()) {
+          group.push(polygon2);
+          polygon2.forEach(function(ring) {
+            ring.forEach(function(arc) {
+              polygonsByArc[arc < 0 ? ~arc : arc].forEach(function(polygon3) {
+                if (!polygon3._) {
+                  polygon3._ = 1;
+                  neighbors.push(polygon3);
+                }
+              });
+            });
+          });
+        }
+      }
+    });
+    polygons.forEach(function(polygon2) {
+      delete polygon2._;
+    });
+    return {
+      type: "MultiPolygon",
+      arcs: groups.map(function(polygons2) {
+        var arcs = [], n;
+        polygons2.forEach(function(polygon2) {
+          polygon2.forEach(function(ring) {
+            ring.forEach(function(arc) {
+              if (polygonsByArc[arc < 0 ? ~arc : arc].length < 2) {
+                arcs.push(arc);
+              }
+            });
+          });
+        });
+        arcs = stitch_default(topology, arcs);
+        if ((n = arcs.length) > 1) {
+          for (var i = 1, k = area(arcs[0]), ki, t; i < n; ++i) {
+            if ((ki = area(arcs[i])) > k) {
+              t = arcs[0], arcs[0] = arcs[i], arcs[i] = t, k = ki;
+            }
+          }
+        }
+        return arcs;
+      }).filter(function(arcs) {
+        return arcs.length > 0;
+      })
+    };
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/object.js
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/bounds.js
+  function bounds_default(objects) {
+    var x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    function boundGeometry(geometry) {
+      if (geometry != null && hasOwnProperty.call(boundGeometryType, geometry.type)) boundGeometryType[geometry.type](geometry);
+    }
+    var boundGeometryType = {
+      GeometryCollection: function(o) {
+        o.geometries.forEach(boundGeometry);
+      },
+      Point: function(o) {
+        boundPoint(o.coordinates);
+      },
+      MultiPoint: function(o) {
+        o.coordinates.forEach(boundPoint);
+      },
+      LineString: function(o) {
+        boundLine(o.arcs);
+      },
+      MultiLineString: function(o) {
+        o.arcs.forEach(boundLine);
+      },
+      Polygon: function(o) {
+        o.arcs.forEach(boundLine);
+      },
+      MultiPolygon: function(o) {
+        o.arcs.forEach(boundMultiLine);
+      }
+    };
+    function boundPoint(coordinates) {
+      var x = coordinates[0], y = coordinates[1];
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (y < y0) y0 = y;
+      if (y > y1) y1 = y;
+    }
+    function boundLine(coordinates) {
+      coordinates.forEach(boundPoint);
+    }
+    function boundMultiLine(coordinates) {
+      coordinates.forEach(boundLine);
+    }
+    for (var key in objects) {
+      boundGeometry(objects[key]);
+    }
+    return x1 >= x0 && y1 >= y0 ? [x0, y0, x1, y1] : void 0;
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/hash/hashset.js
+  function hashset_default(size, hash, equal, type, empty) {
+    if (arguments.length === 3) {
+      type = Array;
+      empty = null;
+    }
+    var store = new type(size = 1 << Math.max(4, Math.ceil(Math.log(size) / Math.LN2))), mask = size - 1;
+    for (var i = 0; i < size; ++i) {
+      store[i] = empty;
+    }
+    function add(value) {
+      var index = hash(value) & mask, match = store[index], collisions = 0;
+      while (match != empty) {
+        if (equal(match, value)) return true;
+        if (++collisions >= size) throw new Error("full hashset");
+        match = store[index = index + 1 & mask];
+      }
+      store[index] = value;
+      return true;
+    }
+    function has(value) {
+      var index = hash(value) & mask, match = store[index], collisions = 0;
+      while (match != empty) {
+        if (equal(match, value)) return true;
+        if (++collisions >= size) break;
+        match = store[index = index + 1 & mask];
+      }
+      return false;
+    }
+    function values() {
+      var values2 = [];
+      for (var i2 = 0, n = store.length; i2 < n; ++i2) {
+        var match = store[i2];
+        if (match != empty) values2.push(match);
+      }
+      return values2;
+    }
+    return {
+      add,
+      has,
+      values
+    };
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/hash/hashmap.js
+  function hashmap_default(size, hash, equal, keyType, keyEmpty, valueType) {
+    if (arguments.length === 3) {
+      keyType = valueType = Array;
+      keyEmpty = null;
+    }
+    var keystore = new keyType(size = 1 << Math.max(4, Math.ceil(Math.log(size) / Math.LN2))), valstore = new valueType(size), mask = size - 1;
+    for (var i = 0; i < size; ++i) {
+      keystore[i] = keyEmpty;
+    }
+    function set(key, value) {
+      var index = hash(key) & mask, matchKey = keystore[index], collisions = 0;
+      while (matchKey != keyEmpty) {
+        if (equal(matchKey, key)) return valstore[index] = value;
+        if (++collisions >= size) throw new Error("full hashmap");
+        matchKey = keystore[index = index + 1 & mask];
+      }
+      keystore[index] = key;
+      valstore[index] = value;
+      return value;
+    }
+    function maybeSet(key, value) {
+      var index = hash(key) & mask, matchKey = keystore[index], collisions = 0;
+      while (matchKey != keyEmpty) {
+        if (equal(matchKey, key)) return valstore[index];
+        if (++collisions >= size) throw new Error("full hashmap");
+        matchKey = keystore[index = index + 1 & mask];
+      }
+      keystore[index] = key;
+      valstore[index] = value;
+      return value;
+    }
+    function get(key, missingValue) {
+      var index = hash(key) & mask, matchKey = keystore[index], collisions = 0;
+      while (matchKey != keyEmpty) {
+        if (equal(matchKey, key)) return valstore[index];
+        if (++collisions >= size) break;
+        matchKey = keystore[index = index + 1 & mask];
+      }
+      return missingValue;
+    }
+    function keys() {
+      var keys2 = [];
+      for (var i2 = 0, n = keystore.length; i2 < n; ++i2) {
+        var matchKey = keystore[i2];
+        if (matchKey != keyEmpty) keys2.push(matchKey);
+      }
+      return keys2;
+    }
+    return {
+      set,
+      maybeSet,
+      // set if unset
+      get,
+      keys
+    };
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/hash/point-equal.js
+  function point_equal_default(pointA, pointB) {
+    return pointA[0] === pointB[0] && pointA[1] === pointB[1];
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/hash/point-hash.js
+  var buffer = new ArrayBuffer(16);
+  var floats = new Float64Array(buffer);
+  var uints = new Uint32Array(buffer);
+  function point_hash_default(point2) {
+    floats[0] = point2[0];
+    floats[1] = point2[1];
+    var hash = uints[0] ^ uints[1];
+    hash = hash << 5 ^ hash >> 7 ^ uints[2] ^ uints[3];
+    return hash & 2147483647;
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/join.js
+  function join_default(topology) {
+    var coordinates = topology.coordinates, lines = topology.lines, rings = topology.rings, indexes = index(), visitedByIndex = new Int32Array(coordinates.length), leftByIndex = new Int32Array(coordinates.length), rightByIndex = new Int32Array(coordinates.length), junctionByIndex = new Int8Array(coordinates.length), junctionCount = 0, i, n, previousIndex, currentIndex, nextIndex;
+    for (i = 0, n = coordinates.length; i < n; ++i) {
+      visitedByIndex[i] = leftByIndex[i] = rightByIndex[i] = -1;
+    }
+    for (i = 0, n = lines.length; i < n; ++i) {
+      var line = lines[i], lineStart = line[0], lineEnd = line[1];
+      currentIndex = indexes[lineStart];
+      nextIndex = indexes[++lineStart];
+      ++junctionCount, junctionByIndex[currentIndex] = 1;
+      while (++lineStart <= lineEnd) {
+        sequence(i, previousIndex = currentIndex, currentIndex = nextIndex, nextIndex = indexes[lineStart]);
+      }
+      ++junctionCount, junctionByIndex[nextIndex] = 1;
+    }
+    for (i = 0, n = coordinates.length; i < n; ++i) {
+      visitedByIndex[i] = -1;
+    }
+    for (i = 0, n = rings.length; i < n; ++i) {
+      var ring = rings[i], ringStart = ring[0] + 1, ringEnd = ring[1];
+      previousIndex = indexes[ringEnd - 1];
+      currentIndex = indexes[ringStart - 1];
+      nextIndex = indexes[ringStart];
+      sequence(i, previousIndex, currentIndex, nextIndex);
+      while (++ringStart <= ringEnd) {
+        sequence(i, previousIndex = currentIndex, currentIndex = nextIndex, nextIndex = indexes[ringStart]);
+      }
+    }
+    function sequence(i2, previousIndex2, currentIndex2, nextIndex2) {
+      if (visitedByIndex[currentIndex2] === i2) return;
+      visitedByIndex[currentIndex2] = i2;
+      var leftIndex = leftByIndex[currentIndex2];
+      if (leftIndex >= 0) {
+        var rightIndex = rightByIndex[currentIndex2];
+        if ((leftIndex !== previousIndex2 || rightIndex !== nextIndex2) && (leftIndex !== nextIndex2 || rightIndex !== previousIndex2)) {
+          ++junctionCount, junctionByIndex[currentIndex2] = 1;
+        }
+      } else {
+        leftByIndex[currentIndex2] = previousIndex2;
+        rightByIndex[currentIndex2] = nextIndex2;
+      }
+    }
+    function index() {
+      var indexByPoint = hashmap_default(coordinates.length * 1.4, hashIndex, equalIndex, Int32Array, -1, Int32Array), indexes2 = new Int32Array(coordinates.length);
+      for (var i2 = 0, n2 = coordinates.length; i2 < n2; ++i2) {
+        indexes2[i2] = indexByPoint.maybeSet(i2, i2);
+      }
+      return indexes2;
+    }
+    function hashIndex(i2) {
+      return point_hash_default(coordinates[i2]);
+    }
+    function equalIndex(i2, j2) {
+      return point_equal_default(coordinates[i2], coordinates[j2]);
+    }
+    visitedByIndex = leftByIndex = rightByIndex = null;
+    var junctionByPoint = hashset_default(junctionCount * 1.4, point_hash_default, point_equal_default), j;
+    for (i = 0, n = coordinates.length; i < n; ++i) {
+      if (junctionByIndex[j = indexes[i]]) {
+        junctionByPoint.add(coordinates[j]);
+      }
+    }
+    return junctionByPoint;
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/cut.js
+  function cut_default(topology) {
+    var junctions = join_default(topology), coordinates = topology.coordinates, lines = topology.lines, rings = topology.rings, next, i, n;
+    for (i = 0, n = lines.length; i < n; ++i) {
+      var line = lines[i], lineMid = line[0], lineEnd = line[1];
+      while (++lineMid < lineEnd) {
+        if (junctions.has(coordinates[lineMid])) {
+          next = { 0: lineMid, 1: line[1] };
+          line[1] = lineMid;
+          line = line.next = next;
+        }
+      }
+    }
+    for (i = 0, n = rings.length; i < n; ++i) {
+      var ring = rings[i], ringStart = ring[0], ringMid = ringStart, ringEnd = ring[1], ringFixed = junctions.has(coordinates[ringStart]);
+      while (++ringMid < ringEnd) {
+        if (junctions.has(coordinates[ringMid])) {
+          if (ringFixed) {
+            next = { 0: ringMid, 1: ring[1] };
+            ring[1] = ringMid;
+            ring = ring.next = next;
+          } else {
+            rotateArray(coordinates, ringStart, ringEnd, ringEnd - ringMid);
+            coordinates[ringEnd] = coordinates[ringStart];
+            ringFixed = true;
+            ringMid = ringStart;
+          }
+        }
+      }
+    }
+    return topology;
+  }
+  function rotateArray(array, start, end, offset) {
+    reverse(array, start, end);
+    reverse(array, start, start + offset);
+    reverse(array, start + offset, end);
+  }
+  function reverse(array, start, end) {
+    for (var mid = start + (end-- - start >> 1), t; start < mid; ++start, --end) {
+      t = array[start], array[start] = array[end], array[end] = t;
+    }
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/dedup.js
+  function dedup_default(topology) {
+    var coordinates = topology.coordinates, lines = topology.lines, line, rings = topology.rings, ring, arcCount = lines.length + rings.length, i, n;
+    delete topology.lines;
+    delete topology.rings;
+    for (i = 0, n = lines.length; i < n; ++i) {
+      line = lines[i];
+      while (line = line.next) ++arcCount;
+    }
+    for (i = 0, n = rings.length; i < n; ++i) {
+      ring = rings[i];
+      while (ring = ring.next) ++arcCount;
+    }
+    var arcsByEnd = hashmap_default(arcCount * 2 * 1.4, point_hash_default, point_equal_default), arcs = topology.arcs = [];
+    for (i = 0, n = lines.length; i < n; ++i) {
+      line = lines[i];
+      do {
+        dedupLine(line);
+      } while (line = line.next);
+    }
+    for (i = 0, n = rings.length; i < n; ++i) {
+      ring = rings[i];
+      if (ring.next) {
+        do {
+          dedupLine(ring);
+        } while (ring = ring.next);
+      } else {
+        dedupRing(ring);
+      }
+    }
+    function dedupLine(arc) {
+      var startPoint, endPoint, startArcs, startArc, endArcs, endArc, i2, n2;
+      if (startArcs = arcsByEnd.get(startPoint = coordinates[arc[0]])) {
+        for (i2 = 0, n2 = startArcs.length; i2 < n2; ++i2) {
+          startArc = startArcs[i2];
+          if (equalLine(startArc, arc)) {
+            arc[0] = startArc[0];
+            arc[1] = startArc[1];
+            return;
+          }
+        }
+      }
+      if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[1]])) {
+        for (i2 = 0, n2 = endArcs.length; i2 < n2; ++i2) {
+          endArc = endArcs[i2];
+          if (reverseEqualLine(endArc, arc)) {
+            arc[1] = endArc[0];
+            arc[0] = endArc[1];
+            return;
+          }
+        }
+      }
+      if (startArcs) startArcs.push(arc);
+      else arcsByEnd.set(startPoint, [arc]);
+      if (endArcs) endArcs.push(arc);
+      else arcsByEnd.set(endPoint, [arc]);
+      arcs.push(arc);
+    }
+    function dedupRing(arc) {
+      var endPoint, endArcs, endArc, i2, n2;
+      if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[0]])) {
+        for (i2 = 0, n2 = endArcs.length; i2 < n2; ++i2) {
+          endArc = endArcs[i2];
+          if (equalRing(endArc, arc)) {
+            arc[0] = endArc[0];
+            arc[1] = endArc[1];
+            return;
+          }
+          if (reverseEqualRing(endArc, arc)) {
+            arc[0] = endArc[1];
+            arc[1] = endArc[0];
+            return;
+          }
+        }
+      }
+      if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[0] + findMinimumOffset(arc)])) {
+        for (i2 = 0, n2 = endArcs.length; i2 < n2; ++i2) {
+          endArc = endArcs[i2];
+          if (equalRing(endArc, arc)) {
+            arc[0] = endArc[0];
+            arc[1] = endArc[1];
+            return;
+          }
+          if (reverseEqualRing(endArc, arc)) {
+            arc[0] = endArc[1];
+            arc[1] = endArc[0];
+            return;
+          }
+        }
+      }
+      if (endArcs) endArcs.push(arc);
+      else arcsByEnd.set(endPoint, [arc]);
+      arcs.push(arc);
+    }
+    function equalLine(arcA, arcB) {
+      var ia = arcA[0], ib = arcB[0], ja = arcA[1], jb = arcB[1];
+      if (ia - ja !== ib - jb) return false;
+      for (; ia <= ja; ++ia, ++ib) if (!point_equal_default(coordinates[ia], coordinates[ib])) return false;
+      return true;
+    }
+    function reverseEqualLine(arcA, arcB) {
+      var ia = arcA[0], ib = arcB[0], ja = arcA[1], jb = arcB[1];
+      if (ia - ja !== ib - jb) return false;
+      for (; ia <= ja; ++ia, --jb) if (!point_equal_default(coordinates[ia], coordinates[jb])) return false;
+      return true;
+    }
+    function equalRing(arcA, arcB) {
+      var ia = arcA[0], ib = arcB[0], ja = arcA[1], jb = arcB[1], n2 = ja - ia;
+      if (n2 !== jb - ib) return false;
+      var ka = findMinimumOffset(arcA), kb = findMinimumOffset(arcB);
+      for (var i2 = 0; i2 < n2; ++i2) {
+        if (!point_equal_default(coordinates[ia + (i2 + ka) % n2], coordinates[ib + (i2 + kb) % n2])) return false;
+      }
+      return true;
+    }
+    function reverseEqualRing(arcA, arcB) {
+      var ia = arcA[0], ib = arcB[0], ja = arcA[1], jb = arcB[1], n2 = ja - ia;
+      if (n2 !== jb - ib) return false;
+      var ka = findMinimumOffset(arcA), kb = n2 - findMinimumOffset(arcB);
+      for (var i2 = 0; i2 < n2; ++i2) {
+        if (!point_equal_default(coordinates[ia + (i2 + ka) % n2], coordinates[jb - (i2 + kb) % n2])) return false;
+      }
+      return true;
+    }
+    function findMinimumOffset(arc) {
+      var start = arc[0], end = arc[1], mid = start, minimum = mid, minimumPoint = coordinates[mid];
+      while (++mid < end) {
+        var point2 = coordinates[mid];
+        if (point2[0] < minimumPoint[0] || point2[0] === minimumPoint[0] && point2[1] < minimumPoint[1]) {
+          minimum = mid;
+          minimumPoint = point2;
+        }
+      }
+      return minimum - start;
+    }
+    return topology;
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/delta.js
+  function delta_default(arcs) {
+    var i = -1, n = arcs.length;
+    while (++i < n) {
+      var arc = arcs[i], j = 0, k = 1, m = arc.length, point2 = arc[0], x0 = point2[0], y0 = point2[1], x1, y1;
+      while (++j < m) {
+        point2 = arc[j], x1 = point2[0], y1 = point2[1];
+        if (x1 !== x0 || y1 !== y0) arc[k++] = [x1 - x0, y1 - y0], x0 = x1, y0 = y1;
+      }
+      if (k === 1) arc[k++] = [0, 0];
+      arc.length = k;
+    }
+    return arcs;
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/extract.js
+  function extract_default(objects) {
+    var index = -1, lines = [], rings = [], coordinates = [];
+    function extractGeometry(geometry) {
+      if (geometry && hasOwnProperty.call(extractGeometryType, geometry.type)) extractGeometryType[geometry.type](geometry);
+    }
+    var extractGeometryType = {
+      GeometryCollection: function(o) {
+        o.geometries.forEach(extractGeometry);
+      },
+      LineString: function(o) {
+        o.arcs = extractLine(o.arcs);
+      },
+      MultiLineString: function(o) {
+        o.arcs = o.arcs.map(extractLine);
+      },
+      Polygon: function(o) {
+        o.arcs = o.arcs.map(extractRing);
+      },
+      MultiPolygon: function(o) {
+        o.arcs = o.arcs.map(extractMultiRing);
+      }
+    };
+    function extractLine(line) {
+      for (var i = 0, n = line.length; i < n; ++i) coordinates[++index] = line[i];
+      var arc = { 0: index - n + 1, 1: index };
+      lines.push(arc);
+      return arc;
+    }
+    function extractRing(ring) {
+      for (var i = 0, n = ring.length; i < n; ++i) coordinates[++index] = ring[i];
+      var arc = { 0: index - n + 1, 1: index };
+      rings.push(arc);
+      return arc;
+    }
+    function extractMultiRing(rings2) {
+      return rings2.map(extractRing);
+    }
+    for (var key in objects) {
+      extractGeometry(objects[key]);
+    }
+    return {
+      type: "Topology",
+      coordinates,
+      lines,
+      rings,
+      objects
+    };
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/geometry.js
+  function geometry_default(inputs) {
+    var outputs = {}, key;
+    for (key in inputs) outputs[key] = geomifyObject(inputs[key]);
+    return outputs;
+  }
+  function geomifyObject(input) {
+    return input == null ? { type: null } : (input.type === "FeatureCollection" ? geomifyFeatureCollection : input.type === "Feature" ? geomifyFeature : geomifyGeometry)(input);
+  }
+  function geomifyFeatureCollection(input) {
+    var output = { type: "GeometryCollection", geometries: input.features.map(geomifyFeature) };
+    if (input.bbox != null) output.bbox = input.bbox;
+    return output;
+  }
+  function geomifyFeature(input) {
+    var output = geomifyGeometry(input.geometry), key;
+    if (input.id != null) output.id = input.id;
+    if (input.bbox != null) output.bbox = input.bbox;
+    for (key in input.properties) {
+      output.properties = input.properties;
+      break;
+    }
+    return output;
+  }
+  function geomifyGeometry(input) {
+    if (input == null) return { type: null };
+    var output = input.type === "GeometryCollection" ? { type: "GeometryCollection", geometries: input.geometries.map(geomifyGeometry) } : input.type === "Point" || input.type === "MultiPoint" ? { type: input.type, coordinates: input.coordinates } : { type: input.type, arcs: input.coordinates };
+    if (input.bbox != null) output.bbox = input.bbox;
+    return output;
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/prequantize.js
+  function prequantize_default(objects, bbox, n) {
+    var x0 = bbox[0], y0 = bbox[1], x1 = bbox[2], y1 = bbox[3], kx = x1 - x0 ? (n - 1) / (x1 - x0) : 1, ky = y1 - y0 ? (n - 1) / (y1 - y0) : 1;
+    function quantizePoint(input) {
+      return [Math.round((input[0] - x0) * kx), Math.round((input[1] - y0) * ky)];
+    }
+    function quantizePoints(input, m) {
+      var i = -1, j = 0, n2 = input.length, output = new Array(n2), pi, px, py, x, y;
+      while (++i < n2) {
+        pi = input[i];
+        x = Math.round((pi[0] - x0) * kx);
+        y = Math.round((pi[1] - y0) * ky);
+        if (x !== px || y !== py) output[j++] = [px = x, py = y];
+      }
+      output.length = j;
+      while (j < m) j = output.push([output[0][0], output[0][1]]);
+      return output;
+    }
+    function quantizeLine(input) {
+      return quantizePoints(input, 2);
+    }
+    function quantizeRing(input) {
+      return quantizePoints(input, 4);
+    }
+    function quantizePolygon(input) {
+      return input.map(quantizeRing);
+    }
+    function quantizeGeometry(o) {
+      if (o != null && hasOwnProperty.call(quantizeGeometryType, o.type)) quantizeGeometryType[o.type](o);
+    }
+    var quantizeGeometryType = {
+      GeometryCollection: function(o) {
+        o.geometries.forEach(quantizeGeometry);
+      },
+      Point: function(o) {
+        o.coordinates = quantizePoint(o.coordinates);
+      },
+      MultiPoint: function(o) {
+        o.coordinates = o.coordinates.map(quantizePoint);
+      },
+      LineString: function(o) {
+        o.arcs = quantizeLine(o.arcs);
+      },
+      MultiLineString: function(o) {
+        o.arcs = o.arcs.map(quantizeLine);
+      },
+      Polygon: function(o) {
+        o.arcs = quantizePolygon(o.arcs);
+      },
+      MultiPolygon: function(o) {
+        o.arcs = o.arcs.map(quantizePolygon);
+      }
+    };
+    for (var key in objects) {
+      quantizeGeometry(objects[key]);
+    }
+    return {
+      scale: [1 / kx, 1 / ky],
+      translate: [x0, y0]
+    };
+  }
+
+  // node_modules/.pnpm/topojson-server@3.0.1/node_modules/topojson-server/src/topology.js
+  function topology_default(objects, quantization) {
+    var bbox = bounds_default(objects = geometry_default(objects)), transform = quantization > 0 && bbox && prequantize_default(objects, bbox, quantization), topology = dedup_default(cut_default(extract_default(objects))), coordinates = topology.coordinates, indexByArc = hashmap_default(topology.arcs.length * 1.4, hashArc, equalArc);
+    objects = topology.objects;
+    topology.bbox = bbox;
+    topology.arcs = topology.arcs.map(function(arc, i) {
+      indexByArc.set(arc, i);
+      return coordinates.slice(arc[0], arc[1] + 1);
+    });
+    delete topology.coordinates;
+    coordinates = null;
+    function indexGeometry(geometry) {
+      if (geometry && hasOwnProperty.call(indexGeometryType, geometry.type)) indexGeometryType[geometry.type](geometry);
+    }
+    var indexGeometryType = {
+      GeometryCollection: function(o) {
+        o.geometries.forEach(indexGeometry);
+      },
+      LineString: function(o) {
+        o.arcs = indexArcs(o.arcs);
+      },
+      MultiLineString: function(o) {
+        o.arcs = o.arcs.map(indexArcs);
+      },
+      Polygon: function(o) {
+        o.arcs = o.arcs.map(indexArcs);
+      },
+      MultiPolygon: function(o) {
+        o.arcs = o.arcs.map(indexMultiArcs);
+      }
+    };
+    function indexArcs(arc) {
+      var indexes = [];
+      do {
+        var index = indexByArc.get(arc);
+        indexes.push(arc[0] < arc[1] ? index : ~index);
+      } while (arc = arc.next);
+      return indexes;
+    }
+    function indexMultiArcs(arcs) {
+      return arcs.map(indexArcs);
+    }
+    for (var key in objects) {
+      indexGeometry(objects[key]);
+    }
+    if (transform) {
+      topology.transform = transform;
+      topology.arcs = delta_default(topology.arcs);
+    }
+    return topology;
+  }
+  function hashArc(arc) {
+    var i = arc[0], j = arc[1], t;
+    if (j < i) t = i, i = j, j = t;
+    return i + 31 * j;
+  }
+  function equalArc(arcA, arcB) {
+    var ia = arcA[0], ja = arcA[1], ib = arcB[0], jb = arcB[1], t;
+    if (ja < ia) t = ia, ia = ja, ja = t;
+    if (jb < ib) t = ib, ib = jb, jb = t;
+    return ia === ib && ja === jb;
+  }
+
+  // node_modules/.pnpm/@turf+concave@7.3.1/node_modules/@turf/concave/dist/esm/index.js
+  function lineDissolve(geojson, options = {}) {
+    options = options || {};
+    if (!isObject(options)) {
+      throw new Error("options is invalid");
+    }
+    const mutate = options.mutate;
+    if (getType(geojson) !== "FeatureCollection") {
+      throw new Error("geojson must be a FeatureCollection");
+    }
+    if (!geojson.features.length) {
+      throw new Error("geojson is empty");
+    }
+    if (mutate === false || mutate === void 0) {
+      geojson = clone(geojson);
+    }
+    const result = [];
+    const lastLine = lineReduce(
+      geojson,
+      (previousLine, currentLine) => {
+        const merged = mergeLineStrings(previousLine, currentLine);
+        if (merged) {
+          return merged;
+        } else {
+          result.push(previousLine);
+          return currentLine;
+        }
+      }
+    );
+    if (lastLine) {
+      result.push(lastLine);
+    }
+    if (!result.length) {
+      return null;
+    } else if (result.length === 1) {
+      return result[0];
+    } else {
+      return multiLineString(
+        result.map((line) => {
+          return line.coordinates;
+        })
+      );
+    }
+  }
+  function coordId(coord) {
+    return coord[0].toString() + "," + coord[1].toString();
+  }
+  function mergeLineStrings(a, b) {
+    const coords1 = a.geometry.coordinates;
+    const coords2 = b.geometry.coordinates;
+    const s1 = coordId(coords1[0]);
+    const e1 = coordId(coords1[coords1.length - 1]);
+    const s2 = coordId(coords2[0]);
+    const e2 = coordId(coords2[coords2.length - 1]);
+    let coords;
+    if (s1 === e2) {
+      coords = coords2.concat(coords1.slice(1));
+    } else if (s2 === e1) {
+      coords = coords1.concat(coords2.slice(1));
+    } else if (s1 === s2) {
+      coords = coords1.slice(1).reverse().concat(coords2);
+    } else if (e1 === e2) {
+      coords = coords1.concat(coords2.reverse().slice(1));
+    } else {
+      return null;
+    }
+    return lineString(coords);
+  }
+  function polygonDissolve(geojson, options = {}) {
+    if (getType(geojson) !== "FeatureCollection") {
+      throw new Error("geojson must be a FeatureCollection");
+    }
+    if (!geojson.features.length) {
+      throw new Error("geojson is empty");
+    }
+    if (options.mutate === false || options.mutate === void 0) {
+      geojson = clone(geojson);
+    }
+    const geoms = [];
+    flattenEach(geojson, (feature2) => {
+      geoms.push(feature2.geometry);
+    });
+    const topo = topology_default({ geoms: geometryCollection(geoms).geometry });
+    const merged = merge_default(topo, topo.objects.geoms.geometries);
+    return merged;
+  }
+  function dissolve(geojson, options = {}) {
+    options = options || {};
+    if (!isObject(options)) {
+      throw new Error("options is invalid");
+    }
+    const mutate = options.mutate;
+    if (getType(geojson) !== "FeatureCollection") {
+      throw new Error("geojson must be a FeatureCollection");
+    }
+    if (!geojson.features.length) {
+      throw new Error("geojson is empty");
+    }
+    if (mutate === false || mutate === void 0) {
+      geojson = clone(geojson);
+    }
+    const type = getHomogenousType(geojson);
+    if (!type) {
+      throw new Error("geojson must be homogenous");
+    }
+    const data = geojson;
+    switch (type) {
+      case "LineString":
+        return lineDissolve(data, options);
+      case "Polygon":
+        return polygonDissolve(data, options);
+      default:
+        throw new Error(type + " is not supported");
+    }
+  }
+  function getHomogenousType(geojson) {
+    const types = {};
+    flattenEach(geojson, (feature2) => {
+      types[feature2.geometry.type] = true;
+    });
+    const keys = Object.keys(types);
+    if (keys.length === 1) {
+      return keys[0];
+    }
+    return null;
+  }
+  function concave(points, options = {}) {
+    const maxEdge = options.maxEdge || Infinity;
+    const cleaned = removeDuplicates(points);
+    const tinPolys = tin(cleaned);
+    tinPolys.features = tinPolys.features.filter((triangle) => {
+      const pt1 = triangle.geometry.coordinates[0][0];
+      const pt2 = triangle.geometry.coordinates[0][1];
+      const pt3 = triangle.geometry.coordinates[0][2];
+      const dist1 = distance(pt1, pt2, options);
+      const dist2 = distance(pt2, pt3, options);
+      const dist3 = distance(pt1, pt3, options);
+      return dist1 <= maxEdge && dist2 <= maxEdge && dist3 <= maxEdge;
+    });
+    if (tinPolys.features.length < 1) {
+      return null;
+    }
+    const dissolved = dissolve(tinPolys);
+    if (dissolved.coordinates.length === 1) {
+      dissolved.coordinates = dissolved.coordinates[0];
+      dissolved.type = "Polygon";
+    }
+    return feature(dissolved);
+  }
+  function removeDuplicates(points) {
+    const cleaned = [];
+    const existing = {};
+    featureEach(points, (pt) => {
+      if (!pt.geometry) {
+        return;
+      }
+      const key = pt.geometry.coordinates.join("-");
+      if (!Object.prototype.hasOwnProperty.call(existing, key)) {
+        cleaned.push(pt);
+        existing[key] = true;
+      }
+    });
+    return featureCollection(cleaned);
+  }
+  var index_default = concave;
+
+  // node_modules/.pnpm/wmap-renderer-canvas@1.0.1/node_modules/wmap-renderer-canvas/src/renderer.js
+  var patternCache = /* @__PURE__ */ new WeakMap();
+  var offscreenCanvasCache = null;
+  var offscreenCanvasContext = null;
+  var internals2 = {
+    // Padding around the axes
+    kAxisLabelPadding: 5,
+    // The default axis labels
+    kAxisLabels: {
+      xAxis: {
+        leading: "Uncharted",
+        trailing: "Industrialised"
+      },
+      yAxis: {
+        top: "Visible",
+        bottom: "Invisible"
+      }
+    }
+  };
+  async function drawBackground(ctx, stages, config) {
+    const { mapWidth, mapHeight } = config.theme.sizes;
+    const { stageForeground, stageBackground } = config.theme.colors;
+    const width = mapWidth;
+    const height = mapHeight;
+    let cachedPatterns = patternCache.get(ctx);
+    if (!cachedPatterns || cachedPatterns.fg !== stageForeground || cachedPatterns.bg !== stageBackground) {
+      cachedPatterns = {
+        fg: stageForeground,
+        bg: stageBackground,
+        stitch: await createPattern(
+          ctx,
+          patterns.stitch,
+          1,
+          stageForeground,
+          stageBackground
+        ),
+        shingles: await createPattern(
+          ctx,
+          patterns.shingles,
+          1,
+          stageForeground,
+          stageBackground
+        ),
+        shadowGrid: await createPattern(
+          ctx,
+          patterns.shadowGrid,
+          1,
+          stageForeground,
+          stageBackground
+        ),
+        wicker: await createPattern(
+          ctx,
+          patterns.wicker,
+          1,
+          stageForeground,
+          stageBackground
+        )
+      };
+      patternCache.set(ctx, cachedPatterns);
+    }
+    const w = (dim) => percentToPixel(dim, width);
+    ctx.fillStyle = cachedPatterns.stitch;
+    ctx.fillRect(0, 0, w(stages[0]), height);
+    ctx.fillStyle = cachedPatterns.shingles;
+    ctx.fillRect(w(stages[0]), 0, w(stages[1]) - w(stages[0]), height);
+    ctx.fillStyle = cachedPatterns.shadowGrid;
+    ctx.fillRect(w(stages[1]), 0, w(stages[2]) - w(stages[1]), height);
+    ctx.fillStyle = cachedPatterns.wicker;
+    ctx.fillRect(w(stages[2]), 0, width - w(stages[2]), height);
+  }
+  function drawAxes(ctx, stages, stageType, config) {
+    const { mapWidth, mapHeight, lineWidth } = config.theme.sizes;
+    const { axis, label } = config.theme.colors;
+    const { family: fontFamily, axisLabel } = config.theme.fonts;
+    const width = mapWidth;
+    const height = mapHeight;
+    const xLabels = internals2.kAxisLabels.xAxis;
+    const yLabels = internals2.kAxisLabels.yAxis;
+    const w = (dim) => percentToPixel(dim, width);
+    ctx.strokeStyle = axis;
+    ctx.lineWidth = lineWidth * 2;
+    ctx.beginPath();
+    ctx.moveTo(0, 0);
+    ctx.lineTo(0, height);
+    ctx.lineTo(width, height);
+    ctx.stroke();
+    ctx.fillStyle = label;
+    ctx.font = `${axisLabel}px ${fontFamily}`;
+    ctx.textBaseline = "top";
+    ctx.save();
+    ctx.translate(-20, 45);
+    ctx.rotate(-Math.PI / 2);
+    ctx.fillText(yLabels.top, 0, 0);
+    ctx.restore();
+    ctx.save();
+    ctx.translate(-20, height);
+    ctx.rotate(-Math.PI / 2);
+    ctx.fillText(yLabels.bottom, 0, 0);
+    ctx.restore();
+    const stageHeight = config.theme.sizes.stageHeight;
+    ctx.textAlign = "left";
+    ctx.fillText(xLabels.leading, 0, -stageHeight / 4);
+    ctx.textAlign = "right";
+    ctx.fillText(xLabels.trailing, width, -stageHeight / 4);
+    ctx.textAlign = "left";
+    ctx.fillText(stageType.stages[0], 0, height + internals2.kAxisLabelPadding);
+    ctx.fillText(
+      stageType.stages[1],
+      w(stages[0]),
+      height + internals2.kAxisLabelPadding
+    );
+    ctx.fillText(
+      stageType.stages[2],
+      w(stages[1]),
+      height + internals2.kAxisLabelPadding
+    );
+    ctx.fillText(
+      stageType.stages[3],
+      w(stages[2]),
+      height + internals2.kAxisLabelPadding
+    );
+  }
+  function drawStages(ctx, stages, config) {
+    const { mapWidth, mapHeight, lineWidth } = config.theme.sizes;
+    const { axis } = config.theme.colors;
+    const width = mapWidth;
+    const height = mapHeight;
+    const w = (dim) => percentToPixel(dim, width);
+    ctx.strokeStyle = axis;
+    ctx.lineWidth = lineWidth * 2;
+    ctx.setLineDash([10, 18]);
+    ctx.globalAlpha = 1;
+    ctx.beginPath();
+    ctx.moveTo(w(stages[0]), 0);
+    ctx.lineTo(w(stages[0]), height);
+    ctx.moveTo(w(stages[1]), 0);
+    ctx.lineTo(w(stages[1]), height);
+    ctx.moveTo(w(stages[2]), 0);
+    ctx.lineTo(w(stages[2]), height);
+    ctx.stroke();
+    ctx.setLineDash([]);
+  }
+  function drawVertexShape(ctx, x, y, shape, config) {
+    const { vertexWidth, vertexHeight } = config.theme.sizes;
+    const { vertex } = config.theme.colors;
+    const width = vertexWidth;
+    const height = vertexHeight;
+    ctx.fillStyle = vertex;
+    switch (shape) {
+      case "circle":
+        ctx.beginPath();
+        ctx.ellipse(
+          x + width / 2,
+          y + height / 2,
+          width / 2,
+          height / 2,
+          0,
+          0,
+          Math.PI * 2
+        );
+        ctx.fill();
+        break;
+      case "square":
+        ctx.fillRect(x, y, width, height);
+        break;
+      case "triangle":
+        ctx.beginPath();
+        ctx.moveTo(x, y + height);
+        ctx.lineTo(x + width, y + height);
+        ctx.lineTo(x + width / 2, y);
+        ctx.closePath();
+        ctx.fill();
+        break;
+      case "x":
+        ctx.strokeStyle = vertex;
+        ctx.lineWidth = 2;
+        ctx.beginPath();
+        ctx.moveTo(x, y);
+        ctx.lineTo(x + width, y + height);
+        ctx.moveTo(x + width, y);
+        ctx.lineTo(x, y + height);
+        ctx.stroke();
+        break;
+      default:
+        ctx.beginPath();
+        ctx.ellipse(
+          x + width / 2,
+          y + height / 2,
+          width / 2,
+          height / 2,
+          0,
+          0,
+          Math.PI * 2
+        );
+        ctx.fill();
+    }
+  }
+  function drawVertices(ctx, components, map, componentMap, configuration) {
+    const {
+      options: { smartLabelPositioning },
+      theme: {
+        sizes: { mapWidth, mapHeight, vertexWidth },
+        colors: { label },
+        fonts: { family: fontFamily, vertexLabel: fontSize }
+      }
+    } = configuration;
+    const width = mapWidth;
+    const height = mapHeight;
+    const w = (dim) => percentToPixel(dim, width);
+    const h = (dim) => percentToPixel(dim, height);
+    ctx.font = `${fontSize}px ${fontFamily}`;
+    ctx.fillStyle = label;
+    ctx.textBaseline = "middle";
+    ctx.textAlign = "left";
+    let allLines, noteRects, inertiaRects;
+    if (smartLabelPositioning) {
+      allLines = collectAllLines(map, configuration, componentMap);
+      noteRects = collectNoteRects(map, configuration, ctx);
+      inertiaRects = collectInertiaRects(map, configuration, componentMap);
+    }
+    for (const component of components) {
+      const [xPercent, yPercent] = component.coordinates;
+      const x = w(xPercent);
+      const y = h(yPercent);
+      drawVertexShape(ctx, x, y, component.shape, configuration);
+      let labelX, labelY;
+      if (smartLabelPositioning) {
+        const position = calculateOptimalLabelPosition(
+          component,
+          map,
+          configuration,
+          ctx,
+          allLines,
+          noteRects,
+          inertiaRects
+        );
+        labelX = position.x;
+        labelY = position.y;
+        ctx.textBaseline = "top";
+      } else {
+        labelX = x + vertexWidth + internals2.kAxisLabelPadding;
+        labelY = y + 7;
+        ctx.textBaseline = "middle";
+      }
+      ctx.fillText(component.label, labelX, labelY);
+    }
+  }
+  function drawDependencies(ctx, dependencies, componentMap, configuration) {
+    const {
+      theme: {
+        sizes: { vertexWidth, vertexHeight, lineWidth, arrowheadSize },
+        colors: { vertex }
+      }
+    } = configuration;
+    ctx.strokeStyle = vertex;
+    ctx.lineWidth = lineWidth;
+    const halfWidth = vertexWidth / 2;
+    const halfHeight = vertexHeight / 2;
+    const arrowAngle = Math.PI / 4;
+    for (const dependency of dependencies) {
+      const fromCoordinates = componentMap[dependency.from.toLowerCase()];
+      const toCoordinates = componentMap[dependency.to.toLowerCase()];
+      if (!fromCoordinates || !toCoordinates) continue;
+      const originX = fromCoordinates[0] + halfWidth;
+      const originY = fromCoordinates[1] + halfHeight;
+      const destX = toCoordinates[0] + halfWidth;
+      const destY = toCoordinates[1] + halfHeight;
+      const angle = Math.atan2(destY - originY, destX - originX);
+      const cosine = Math.cos(angle);
+      const sine = Math.sin(angle);
+      const offsetOriginX = originX + halfWidth * cosine;
+      const offsetOriginY = originY + halfHeight * sine;
+      const offsetDestX = destX - halfWidth * cosine;
+      const offsetDestY = destY - halfHeight * sine;
+      ctx.beginPath();
+      ctx.moveTo(offsetOriginX, offsetOriginY);
+      ctx.lineTo(offsetDestX, offsetDestY);
+      ctx.stroke();
+      if (dependency.isDirected) {
+        const upperAngle = angle - arrowAngle;
+        const lowerAngle = angle + arrowAngle;
+        ctx.beginPath();
+        ctx.moveTo(
+          offsetDestX - arrowheadSize * Math.cos(upperAngle),
+          offsetDestY - arrowheadSize * Math.sin(upperAngle)
+        );
+        ctx.lineTo(offsetDestX, offsetDestY);
+        ctx.lineTo(
+          offsetDestX - arrowheadSize * Math.cos(lowerAngle),
+          offsetDestY - arrowheadSize * Math.sin(lowerAngle)
+        );
+        ctx.stroke();
+      }
+    }
+  }
+  function drawNotes(ctx, notes, configuration) {
+    const {
+      theme: {
+        sizes: { mapWidth, mapHeight, lineWidth },
+        colors: { background, vertex, label },
+        fonts: { family: fontFamily, note: fontSize },
+        lineHeights: { note: lineHeight }
+      }
+    } = configuration;
+    const w = (dim) => percentToPixel(dim, mapWidth);
+    const h = (dim) => percentToPixel(dim, mapHeight);
+    const maxWidth = 400;
+    const padding = internals2.kAxisLabelPadding;
+    ctx.font = `${fontSize}px ${fontFamily}`;
+    ctx.textBaseline = "top";
+    ctx.textAlign = "left";
+    ctx.lineWidth = lineWidth;
+    ctx.fillStyle = background;
+    const noteData = [];
+    for (const note of notes) {
+      const x = w(note.coordinates[0]);
+      const y = h(note.coordinates[1]);
+      const lines = note.text.replace(/\\n/g, "\n").split("\n");
+      let widestLine = 0;
+      for (let i = 0; i < lines.length; i++) {
+        const lineWidth2 = ctx.measureText(lines[i]).width;
+        if (lineWidth2 > widestLine) widestLine = lineWidth2;
+      }
+      const boxWidth = Math.min(maxWidth, widestLine + padding * 2);
+      const boxHeight = lines.length * lineHeight + padding * 2;
+      ctx.fillRect(x, y, boxWidth, boxHeight);
+      noteData.push({ x, y, boxWidth, boxHeight, lines });
+    }
+    ctx.strokeStyle = vertex;
+    for (const { x, y, boxWidth, boxHeight } of noteData) {
+      ctx.strokeRect(x, y, boxWidth, boxHeight);
+    }
+    ctx.fillStyle = label;
+    for (const { x, y, lines } of noteData) {
+      for (let i = 0; i < lines.length; i++) {
+        ctx.fillText(lines[i], x + padding, y + padding + i * lineHeight);
+      }
+    }
+  }
+  function drawInertias(ctx, inertias, componentMap, configuration) {
+    const {
+      theme: {
+        sizes: { vertexWidth, vertexHeight },
+        colors: { inertia }
+      }
+    } = configuration;
+    const cornerRadius = 2;
+    ctx.fillStyle = inertia;
+    for (const inertia2 of inertias) {
+      if (!inertia2.component) return;
+      const coordinates = componentMap[inertia2.component.toLowerCase()];
+      if (!coordinates) return;
+      const x = coordinates[0] + 3 * vertexWidth;
+      const y = coordinates[1] - vertexHeight * 2 / 3;
+      const rectWidth = vertexWidth / 2;
+      const rectHeight = vertexHeight * 2;
+      ctx.beginPath();
+      ctx.roundRect(x, y, rectWidth, rectHeight, cornerRadius);
+      ctx.fill();
+    }
+  }
+  function drawEvolutions(ctx, evolutions, componentMap, configuration) {
+    const {
+      theme: {
+        sizes: {
+          mapWidth,
+          vertexWidth,
+          vertexHeight,
+          lineWidth,
+          arrowheadSize
+        },
+        colors: { evolution }
+      }
+    } = configuration;
+    ctx.strokeStyle = evolution;
+    ctx.lineWidth = lineWidth * 2;
+    ctx.setLineDash([10]);
+    ctx.globalAlpha = 1;
+    evolutions.forEach((evolutionItem) => {
+      const coords = componentMap[evolutionItem.component.toLowerCase()];
+      if (!coords) return;
+      const originX = coords[0];
+      const originY = coords[1];
+      const destX = Math.max(
+        0,
+        Math.min(
+          mapWidth,
+          originX + percentToPixel(evolutionItem.value, mapWidth)
+        )
+      );
+      const destY = originY;
+      const multiplier = destX > originX ? 1 : -1;
+      const upperAngle = -Math.PI / 4;
+      const lowerAngle = Math.PI / 4;
+      const offsetOriginX = originX + multiplier * (vertexWidth / 2) + vertexWidth / 2;
+      const offsetOriginY = originY + vertexHeight / 2;
+      const offsetDestX = destX - multiplier * (vertexWidth / 2) + vertexWidth / 2;
+      const offsetDestY = destY + vertexHeight / 2;
+      ctx.beginPath();
+      ctx.moveTo(offsetOriginX, offsetOriginY);
+      ctx.lineTo(offsetDestX, offsetDestY);
+      ctx.stroke();
+      ctx.beginPath();
+      ctx.moveTo(offsetDestX, offsetDestY);
+      ctx.lineTo(
+        offsetDestX - multiplier * arrowheadSize * Math.cos(upperAngle),
+        offsetDestY - multiplier * arrowheadSize * Math.sin(upperAngle)
+      );
+      ctx.stroke();
+      ctx.beginPath();
+      ctx.moveTo(offsetDestX, offsetDestY);
+      ctx.lineTo(
+        offsetDestX - multiplier * arrowheadSize * Math.cos(lowerAngle),
+        offsetDestY - multiplier * arrowheadSize * Math.sin(lowerAngle)
+      );
+      ctx.stroke();
+    });
+    ctx.setLineDash([]);
+    ctx.globalAlpha = 1;
+  }
+  async function drawGroups(ctx, groups, componentMap, configuration) {
+    const {
+      theme: {
+        colors: { groups: groupColors },
+        sizes: { mapWidth, mapHeight, vertexWidth, vertexHeight },
+        opacity: { groups: groupOpacity }
+      }
+    } = configuration;
+    const width = mapWidth;
+    const height = mapHeight;
+    const isNode = typeof window === "undefined";
+    if (!offscreenCanvasCache || offscreenCanvasCache.width !== width + vertexWidth || offscreenCanvasCache.height !== height + vertexHeight) {
+      if (isNode) {
+        const { createCanvas } = await Promise.resolve().then(() => __toESM(require_browser(), 1));
+        offscreenCanvasCache = createCanvas(
+          width + vertexWidth,
+          height + vertexHeight
+        );
+      } else {
+        offscreenCanvasCache = document.createElement("canvas");
+        offscreenCanvasCache.width = width + vertexWidth;
+        offscreenCanvasCache.height = height + vertexHeight;
+      }
+      offscreenCanvasContext = offscreenCanvasCache.getContext("2d");
+    }
+    groups.forEach((group, groupIndex) => {
+      const componentCoords = group.components.map((label) => componentMap[label.toLowerCase()]).filter(Boolean);
+      if (componentCoords.length === 0) return;
+      const color = groupColors[groupIndex % groupColors.length];
+      let coords;
+      if (componentCoords.length === 1) {
+        const [x, y] = componentCoords[0];
+        const radius = 3;
+        const segments = 16;
+        coords = [];
+        for (let i = 0; i <= segments; i++) {
+          const angle = i / segments * 2 * Math.PI;
+          coords.push([
+            x + radius * Math.cos(angle),
+            y + radius * Math.sin(angle)
+          ]);
+        }
+      } else if (componentCoords.length === 2) {
+        coords = [componentCoords[0], componentCoords[1]];
+      } else {
+        const points = componentCoords.map(([x, y]) => point([x, y]));
+        const fc = featureCollection(points);
+        const hull = index_default(fc);
+        if (!hull) return;
+        coords = hull.geometry.coordinates[0];
+      }
+      offscreenCanvasContext.clearRect(
+        0,
+        0,
+        offscreenCanvasCache.width,
+        offscreenCanvasCache.height
+      );
+      offscreenCanvasContext.setTransform(1, 0, 0, 1, 0, 0);
+      offscreenCanvasContext.translate(vertexWidth / 2, vertexHeight / 2);
+      offscreenCanvasContext.beginPath();
+      coords.forEach(([x, y], i) => {
+        const px = x;
+        const py = y;
+        if (i === 0) {
+          offscreenCanvasContext.moveTo(px, py);
+        } else {
+          offscreenCanvasContext.lineTo(px, py);
+        }
+      });
+      const isLine = componentCoords.length === 2;
+      if (!isLine) {
+        offscreenCanvasContext.closePath();
+        offscreenCanvasContext.fillStyle = color;
+        offscreenCanvasContext.fill();
+      }
+      offscreenCanvasContext.strokeStyle = color;
+      offscreenCanvasContext.lineWidth = 1.75 * vertexWidth;
+      offscreenCanvasContext.lineCap = "round";
+      offscreenCanvasContext.lineJoin = "round";
+      offscreenCanvasContext.stroke();
+      ctx.save();
+      ctx.globalAlpha = groupOpacity;
+      ctx.drawImage(offscreenCanvasCache, 0, 0);
+      ctx.restore();
+    });
+  }
+  async function render(map, ctx, stageType, configuration) {
+    const {
+      options: { showBackground },
+      theme: {
+        colors: { background },
+        sizes: { mapWidth, mapHeight, padding }
+      }
+    } = configuration;
+    const stages = getStageValues(map.stages);
+    const componentMap = createComponentMap(
+      map.components,
+      mapWidth,
+      mapHeight
+    );
+    ctx.fillStyle = background;
+    const totalWidth = mapWidth + padding * 2;
+    const totalHeight = mapHeight + padding * 2;
+    ctx.fillRect(0, 0, totalWidth, totalHeight);
+    ctx.save();
+    ctx.translate(padding, padding);
+    ctx.fillStyle = background;
+    ctx.fillRect(0, 0, mapWidth, mapHeight);
+    if (showBackground) {
+      await drawBackground(ctx, stages, configuration);
+    }
+    drawAxes(ctx, stages, stageType, configuration);
+    drawStages(ctx, stages, configuration);
+    drawDependencies(ctx, map.dependencies, componentMap, configuration);
+    await drawGroups(ctx, map.groups, componentMap, configuration);
+    drawVertices(ctx, map.components, map, componentMap, configuration);
+    drawInertias(ctx, map.inertias, componentMap, configuration);
+    drawEvolutions(ctx, map.evolutions, componentMap, configuration);
+    drawNotes(ctx, map.notes, configuration);
+    ctx.restore();
+  }
+
+  // node_modules/.pnpm/wmap-renderer-canvas@1.0.1/node_modules/wmap-renderer-canvas/src/configuration.js
+  var internals3 = {
+    kDefaults: {
+      options: {
+        showBackground: true,
+        smartLabelPositioning: true
+      },
+      theme: {
+        colors: {
+          background: "#FFFFFF",
+          axis: "#0F261F",
+          vertex: "#0F261F",
+          label: "#0F261F",
+          stageForeground: "#DAE6E3",
+          stageBackground: "#FFFFFF",
+          inertia: "#FA2B00",
+          evolution: "#4F8FE6",
+          groups: [
+            "#4F8FE6",
+            // Olympic Blue
+            "#FA2B00",
+            // Jasper Red
+            "#23C17C",
+            // Light Porcelain Green
+            "#FAED8F",
+            // Naples Yellow
+            "#FFB3F0"
+            // Hermosa Pink
+          ]
+        },
+        sizes: {
+          mapWidth: 1300,
+          mapHeight: 1e3,
+          padding: 42,
+          lineWidth: 0.5,
+          vertexWidth: 25,
+          vertexHeight: 25,
+          arrowheadSize: 10,
+          stageHeight: 100
+        },
+        fonts: {
+          family: '"Helvetica Neue", Helvetica, Arial, sans-serif',
+          axisLabel: 14,
+          vertexLabel: 12,
+          note: 12
+        },
+        lineHeights: {
+          vertexLabel: 18,
+          note: 18
+        },
+        opacity: {
+          groups: 0.1
+        }
+      }
+    }
+  };
+  function extendConfiguration(overrides = {}) {
+    const configuration = {
+      options: Object.assign(
+        {},
+        internals3.kDefaults.options,
+        overrides.options
+      ),
+      theme: {
+        colors: Object.assign(
+          {},
+          internals3.kDefaults.theme.colors,
+          overrides.theme?.colors
+        ),
+        sizes: Object.assign(
+          {},
+          internals3.kDefaults.theme.sizes,
+          overrides.theme?.sizes
+        ),
+        fonts: Object.assign(
+          {},
+          internals3.kDefaults.theme.fonts,
+          overrides.theme?.fonts
+        ),
+        lineHeights: Object.assign(
+          {},
+          internals3.kDefaults.theme.lineHeights,
+          overrides.theme?.lineHeights
+        ),
+        opacity: Object.assign(
+          {},
+          internals3.kDefaults.theme.opacity,
+          overrides.theme?.opacity
+        )
+      }
+    };
+    return configuration;
+  }
+
+  // node_modules/.pnpm/wmap-renderer-canvas@1.0.1/node_modules/wmap-renderer-canvas/src/stage_type.js
+  var StageType = {
+    BEHAVIOR: {
+      name: "Behavior",
+      stages: [
+        "Uncertain when to use",
+        "Learning when to use",
+        "Learning through use",
+        "Known / common usage"
+      ]
+    },
+    CERTAINTY: {
+      name: "Certainty",
+      stages: [
+        "Poorly Understood / exploring the unknown",
+        "Rapid Increase In Learning / discovery becomes refining",
+        "Rapid increase in use / increasing fit for purpose",
+        "Commonly understood (in terms of use)"
+      ]
+    },
+    COMPARISON: {
+      name: "Comparison",
+      stages: [
+        "Constantly changing / a differential / unstable",
+        "Learning from others / testing the water / some evidential support",
+        "Competing models / feature difference / evidential support",
+        "Essential / any advantage is operational / accepted norm"
+      ]
+    },
+    CYNEFIN: {
+      name: "Cynefin",
+      stages: ["Chaotic", "Complex", "Complicated", "Clear"]
+    },
+    DATA: {
+      name: "Data",
+      stages: ["Unmodelled", "Divergent", "Convergent", "Modelled"]
+    },
+    DECISION_DRIVERS: {
+      name: "Decision Drivers",
+      stages: [
+        "Heritage / culture",
+        "Analyses & synthesis",
+        "Analyses & synthesis",
+        "Previous Experience"
+      ]
+    },
+    EFFICIENCY: {
+      name: "Efficiency",
+      stages: [
+        "Reducing the cost of change (experimentation)",
+        "Reducing cost of waste (Learning)",
+        "Reducing cost of waste (Learning)",
+        "Reducing cost of deviation (Volume)"
+      ]
+    },
+    FAILURE: {
+      name: "Failure",
+      stages: [
+        "High / tolerated / assumed to be wrong",
+        "Moderate / unsurprising if wrong but disappointed",
+        "Not tolerated / focus on constant improvement / assumed to be in the right direction / resistance to changing the model",
+        "Surprised by failure / focus on operational efficiency"
+      ]
+    },
+    FOCUS_OF_VALUE: {
+      name: "Focus Of Value",
+      stages: [
+        "High future worth but immediate investment",
+        "Seeking ways to profit and a ROI / seeking confirmation of value",
+        "High profitability per unit / a valuable model / a feeling of understanding / focus on exploitation",
+        "High volume / reducing margin / important but invisible / an essential component of something more complex"
+      ]
+    },
+    ACTIVITIES: {
+      name: "Activities",
+      stages: [
+        "Genesis",
+        "Custom",
+        "Product (+rental)",
+        "Commodity (+utility)"
+      ]
+    },
+    KNOWLEDGE_MANAGEMENT: {
+      name: "Knowledge Management",
+      stages: [
+        "Uncertain",
+        "Learning on use / focused on testing prediction",
+        "Learning on operation / using prediction / verification",
+        "Known / accepted"
+      ]
+    },
+    KNOWLEDGE: {
+      name: "Knowledge",
+      stages: ["Concept", "Hypothesis", "Theory", "Accepted"]
+    },
+    MARKET_ACTION: {
+      name: "Market Action",
+      stages: [
+        "Gambling / driven by gut",
+        'Exploring a "found" value',
+        "Market analysis / listening to customers",
+        "Metric driven / build what is needed"
+      ]
+    },
+    MARKET_PERCEPTION: {
+      name: "Market Perception",
+      stages: [
+        'Chaotic (non-linear) / domain of the "crazy"',
+        'Domain of "experts"',
+        'Increasing expectation of use / domain of "professionals"',
+        "Ordered (appearance of being linear) / trivial / formula to be applied"
+      ]
+    },
+    MARKET: {
+      name: "Market",
+      stages: [
+        "Undefined Market",
+        "Forming Market / an array of competing forms and models of understanding",
+        "Growing Market / consolidation to a few competing but more accepted forms",
+        "Mature Market / stabilised to an accepted form"
+      ]
+    },
+    PERCEPTION_IN_INDUSTRY: {
+      name: "Perception In Industry",
+      stages: [
+        "Future source of competitive advantage / unpredictable / unknown",
+        "Seen as a scompetitive advantage / a differential / ROI / case examples",
+        "Advantage through implementation / features / this model is better than that",
+        "Cost of doing business / accepted / specific defined models"
+      ]
+    },
+    EVOLUTION_STAGE: {
+      name: "Evolution Stage",
+      stages: ["Stage I", "Stage II", "Stage III", "Stage IV"]
+    },
+    PRACTICE: {
+      name: "Practice",
+      stages: ["Novel", "Emerging", "Good", "Best"]
+    },
+    PUBLICATION_TYPES: {
+      name: "Publication Types",
+      stages: [
+        "Describe the wonder of the thing / the discovery of some marvel / a new land / an unknown frontier",
+        "Focused on build / construct / awareness and learning / many models of explanation / no accepted forms / a wild west",
+        "Maintenance / operations / installation / comparison between competing forms / feature analysis",
+        "Focused on use / increasingly an accepted, almost invisible component"
+      ]
+    },
+    UBIQUITY: {
+      name: "Ubiquity",
+      stages: [
+        "Rare",
+        "Slowly Increasing",
+        "Rapidly Increasing",
+        "Widespread in the applicable market / ecosystem"
+      ]
+    },
+    UNDERSTANDING: {
+      name: "Understanding",
+      stages: [
+        "Poorly Understood / unpredictable",
+        "Increasing understanding / development of measures",
+        "Increasing education / constant refinement of needs / measures",
+        "Believed to be well defined / stable / measurable"
+      ]
+    },
+    USER_PERCEPTION: {
+      name: "User Perception",
+      stages: [
+        "Different / confusing / exciting / surprising / dangerous",
+        "Leading edge / emerging / unceirtanty over results",
+        "Increasingly common / disappointed if not used or available / feeling left behind",
+        "Standard / expected / feeling of shock if not used"
+      ]
+    }
+  };
+
+  // node_modules/.pnpm/wmap-renderer-canvas@1.0.1/node_modules/wmap-renderer-canvas/src/index.js
+  async function renderToCanvas(map, canvas, stageType = StageType.ACTIVITIES, overrides = {}) {
+    if (!map) {
+      throw new Error("Map object is required");
+    }
+    if (!canvas) {
+      throw new Error("Canvas is required");
+    }
+    const configuration = extendConfiguration(overrides);
+    const { mapWidth, mapHeight, padding } = configuration.theme.sizes;
+    const totalWidth = mapWidth + padding * 2;
+    const totalHeight = mapHeight + padding * 2;
+    if (canvas.width !== totalWidth || canvas.height !== totalHeight) {
+      canvas.width = totalWidth;
+      canvas.height = totalHeight;
+    }
+    const context = canvas.getContext("2d");
+    await render(map, context, stageType, configuration);
+  }
+
+  // src/wmap.js
+  var import_isomorphic_dompurify = __toESM(require_browser2(), 1);
+  var internals4 = {
+    kStyleSheet: "/plugins/wmap/wmap.css",
+    kCanvasWidth: 1384,
+    kCanvasHeight: 1884,
+    // Returns HTML that shows a message in the wiki.
+    message(text) {
+      return `
+        <div class="viewer" data-item="viewer" style="width:98%">
+          <div style="width:80%; padding:8px; color:gray; background-color:#eee; margin:0 auto; text-align:center">
+            <i>${text}</i>
+          </div>
+        </div>`;
+    },
+    // Creates a wmap PNG from text.
+    async renderImage(source) {
+      const parsedText = parse(source);
+      const canvas = document.createElement("canvas");
+      canvas.width = internals4.kCanvasWidth;
+      canvas.height = internals4.kCanvasHeight;
+      await renderToCanvas(parsedText, canvas);
+      return canvas.toDataURL();
+    },
+    // Starts a download of the image.
+    download(filename, text) {
+      var element = document.createElement("a");
+      element.setAttribute("href", text);
+      element.setAttribute("download", filename);
+      element.style.display = "none";
+      document.body.appendChild(element);
+      element.click();
+      document.body.removeChild(element);
+    },
+    // Replaces the image in a window. Intended for use in a dialog.
+    replaceImage(window2, imageData) {
+      const $container = window2.document.querySelector("main");
+      $container.querySelectorAll("img").forEach((img) => img.remove());
+      const image = document.createElement("img");
+      image.src = imageData;
+      image.alt = "Wardley map rendered from source.";
+      $container.appendChild(image);
+    }
+  };
+  var emit = function emit2($item) {
+    const hasStyleSheet = [...document.styleSheets].some(
+      (styleSheet) => styleSheet.href.endsWith(internals4.kStyleSheet)
+    );
+    if (!hasStyleSheet) {
+      console.log("Adding wmap stylesheet.");
+      const link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = internals4.kStyleSheet;
+      link.type = "text/css";
+      document.getElementsByTagName("head")[0].appendChild(link);
+    }
+    return $item.append(internals4.message("Loading Wardley Map"));
+  };
+  var bind = async function bind2($item, item) {
+    $item.on("dblclick", () => {
+      return wiki.textEditor($item, item);
+    });
+    $item.on("click", "a", (event) => {
+      const { currentTarget } = event;
+      const action = currentTarget.dataset?.action;
+      if (!action) {
+        return;
+      }
+      event.stopPropagation();
+      event.preventDefault();
+      switch (action) {
+        case "download":
+          {
+            const slug = $item.parents(".page").attr("id");
+            internals4.download(`${slug}.png`, item.png);
+          }
+          break;
+        case "zoom":
+          {
+            const shouldOpenStandalone = !!event.shiftKey;
+            const target = shouldOpenStandalone ? "_blank" : "wmap";
+            const dialog = window.open(
+              "/plugins/wmap/dialog/#",
+              target,
+              "popup,height=600,width=800"
+            );
+            if (dialog.location.pathname !== "/plugins/wmap/dialog/") {
+              dialog.addEventListener("load", () => {
+                internals4.replaceImage(dialog, item.png);
+              });
+            } else {
+              internals4.replaceImage(dialog, item.png);
+            }
+          }
+          break;
+      }
+    });
+    try {
+      let imageData = await internals4.renderImage(item.text);
+      item.png = imageData;
+      $item.find(".viewer").html(`
+            <article class="wardley-map"><img src="${imageData}"</article>
+            <nav class="actions">
+                <menu>
+                    <li><a href="#" data-action="download" title="Download"><img width="18" height="18" alt="download" src='data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" viewBox="0 0 24 24" fill="grey"><g><rect fill="none" height="24" width="24"/></g><g><path d="M5,20h14v-2H5V20z M19,9h-4V3H9v6H5l7,7L19,9z"/></g></svg>'></a></li>
+                    <li><a href="#" data-action="zoom" title="Zoom"><img width="18" height="18" alt="toggle zoom" src='data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" viewBox="0 0 24 24"><g><rect fill="none" height="24" width="24"/></g><g><g><g><path fill="grey" d="M15,3l2.3,2.3l-2.89,2.87l1.42,1.42L18.7,6.7L21,9V3H15z M3,9l2.3-2.3l2.87,2.89l1.42-1.42L6.7,5.3L9,3H3V9z M9,21 l-2.3-2.3l2.89-2.87l-1.42-1.42L5.3,17.3L3,15v6H9z M21,15l-2.3,2.3l-2.87-2.89l-1.42,1.42l2.89,2.87L15,21h6V15z"/></g></g></g></svg>'></a></li>
+                </menu>
+            </nav>
+            `);
+    } catch (err) {
+      console.log("Failed to parse wardley map: ", err);
+      $item.html(internals4.message(err.message));
+    }
+  };
+  if (typeof window !== "undefined" && window !== null) {
+    if (!window.plugins.wmap) {
+      window.plugins.wmap = { emit, bind };
+    }
+  }
+  var expand = function(text) {
+    return import_isomorphic_dompurify.default.sanitize(text);
+  };
+  var wmap = typeof window === "undefined" ? { expand } : void 0;
+})();
+/*! Bundled license information:
+
+dompurify/dist/purify.cjs.js:
+  (*! @license DOMPurify 3.3.1 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.3.1/LICENSE *)
+*/