@design.estate/dees-domtools 2.0.61 → 2.0.63

package/dist_bundle/bundle.js

@@ -1896,8 +1896,8 @@ var require_get_intrinsic = __commonJS({
         throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
       }
       var result = [];
-      $replace(string3, rePropName, function(match2, number2, quote, subString) {
-        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number2 || match2;
+      $replace(string3, rePropName, function(match, number2, quote, subString) {
+        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number2 || match;
       });
       return result;
     };
@@ -3570,11 +3570,11 @@ var require_lib = __commonJS({
   "node_modules/.pnpm/qs@6.12.1/node_modules/qs/lib/index.js"(exports, module) {
     "use strict";
     var stringify5 = require_stringify();
-    var parse5 = require_parse();
+    var parse4 = require_parse();
     var formats = require_formats();
     module.exports = {
       formats,
-      parse: parse5,
+      parse: parse4,
       stringify: stringify5
     };
   }
@@ -3887,8 +3887,8 @@ var require_url = __commonJS({
       if (search2 && search2.charAt(0) !== "?") {
         search2 = "?" + search2;
       }
-      pathname = pathname.replace(/[?#]/g, function(match2) {
-        return encodeURIComponent(match2);
+      pathname = pathname.replace(/[?#]/g, function(match) {
+        return encodeURIComponent(match);
       });
       search2 = search2.replace("#", "%23");
       return protocol + host + pathname + search2 + hash;
@@ -4134,11 +4134,11 @@ var require_min_indent = __commonJS({
   "node_modules/.pnpm/min-indent@1.0.1/node_modules/min-indent/index.js"(exports, module) {
     "use strict";
     module.exports = (string3) => {
-      const match2 = string3.match(/^[ \t]*(?=\S)/gm);
-      if (!match2) {
+      const match = string3.match(/^[ \t]*(?=\S)/gm);
+      if (!match) {
         return 0;
       }
-      return match2.reduce((r3, a2) => Math.min(r3, a2.length), Infinity);
+      return match.reduce((r3, a2) => Math.min(r3, a2.length), Infinity);
     };
   }
 });
@@ -5788,33 +5788,33 @@ var require_timestamp = __commonJS({
       return false;
     }
     function constructYamlTimestamp(data) {
-      var match2, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
-      match2 = YAML_DATE_REGEXP.exec(data);
-      if (match2 === null)
-        match2 = YAML_TIMESTAMP_REGEXP.exec(data);
-      if (match2 === null)
+      var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
+      match = YAML_DATE_REGEXP.exec(data);
+      if (match === null)
+        match = YAML_TIMESTAMP_REGEXP.exec(data);
+      if (match === null)
         throw new Error("Date resolve error");
-      year = +match2[1];
-      month = +match2[2] - 1;
-      day = +match2[3];
-      if (!match2[4]) {
+      year = +match[1];
+      month = +match[2] - 1;
+      day = +match[3];
+      if (!match[4]) {
         return new Date(Date.UTC(year, month, day));
       }
-      hour = +match2[4];
-      minute = +match2[5];
-      second = +match2[6];
-      if (match2[7]) {
-        fraction = match2[7].slice(0, 3);
+      hour = +match[4];
+      minute = +match[5];
+      second = +match[6];
+      if (match[7]) {
+        fraction = match[7].slice(0, 3);
         while (fraction.length < 3) {
           fraction += "0";
         }
         fraction = +fraction;
       }
-      if (match2[9]) {
-        tz_hour = +match2[10];
-        tz_minute = +(match2[11] || 0);
+      if (match[9]) {
+        tz_hour = +match[10];
+        tz_minute = +(match[11] || 0);
         delta = (tz_hour * 60 + tz_minute) * 6e4;
-        if (match2[9] === "-")
+        if (match[9] === "-")
           delta = -delta;
       }
       date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
@@ -6357,19 +6357,19 @@ var require_loader = __commonJS({
     }
     var directiveHandlers = {
       YAML: function handleYamlDirective(state, name, args) {
-        var match2, major, minor;
+        var match, major, minor;
         if (state.version !== null) {
           throwError(state, "duplication of %YAML directive");
         }
         if (args.length !== 1) {
           throwError(state, "YAML directive accepts exactly one argument");
         }
-        match2 = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
-        if (match2 === null) {
+        match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+        if (match === null) {
           throwError(state, "ill-formed argument of the YAML directive");
         }
-        major = parseInt(match2[1], 10);
-        minor = parseInt(match2[2], 10);
+        major = parseInt(match[1], 10);
+        minor = parseInt(match[2], 10);
         if (major !== 1) {
           throwError(state, "unacceptable YAML version of the document");
         }
@@ -7596,7 +7596,7 @@ var require_dumper = __commonJS({
           case STYLE_FOLDED:
             return ">" + blockHeader(string3, state.indent) + dropEndingNewline(indentString(foldString(string3, lineWidth), indent3));
           case STYLE_DOUBLE:
-            return '"' + escapeString2(string3, lineWidth) + '"';
+            return '"' + escapeString(string3, lineWidth) + '"';
           default:
             throw new YAMLException("impossible error: invalid scalar style");
         }
@@ -7622,9 +7622,9 @@ var require_dumper = __commonJS({
       }();
       var prevMoreIndented = string3[0] === "\n" || string3[0] === " ";
       var moreIndented;
-      var match2;
-      while (match2 = lineRe.exec(string3)) {
-        var prefix = match2[1], line = match2[2];
+      var match;
+      while (match = lineRe.exec(string3)) {
+        var prefix = match[1], line = match[2];
         moreIndented = line[0] === " ";
         result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
         prevMoreIndented = moreIndented;
@@ -7635,11 +7635,11 @@ var require_dumper = __commonJS({
       if (line === "" || line[0] === " ")
         return line;
       var breakRe = / [^ ]/g;
-      var match2;
+      var match;
       var start = 0, end, curr = 0, next2 = 0;
       var result = "";
-      while (match2 = breakRe.exec(line)) {
-        next2 = match2.index;
+      while (match = breakRe.exec(line)) {
+        next2 = match.index;
         if (next2 - start > width) {
           end = curr > start ? curr : next2;
           result += "\n" + line.slice(start, end);
@@ -7655,7 +7655,7 @@ var require_dumper = __commonJS({
       }
       return result.slice(1);
     }
-    function escapeString2(string3) {
+    function escapeString(string3) {
       var result = "";
       var char, nextChar;
       var escapeSeq;
@@ -8225,6 +8225,369 @@ var require_format = __commonJS({
   }
 });
 
+// node_modules/.pnpm/path-to-regexp@8.2.0/node_modules/path-to-regexp/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/.pnpm/path-to-regexp@8.2.0/node_modules/path-to-regexp/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TokenData = void 0;
+    exports.parse = parse4;
+    exports.compile = compile;
+    exports.match = match;
+    exports.pathToRegexp = pathToRegexp;
+    exports.stringify = stringify5;
+    var DEFAULT_DELIMITER = "/";
+    var NOOP_VALUE = (value2) => value2;
+    var ID_START = /^[$_\p{ID_Start}]$/u;
+    var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
+    var DEBUG_URL = "https://git.new/pathToRegexpError";
+    var SIMPLE_TOKENS = {
+      // Groups.
+      "{": "{",
+      "}": "}",
+      // Reserved.
+      "(": "(",
+      ")": ")",
+      "[": "[",
+      "]": "]",
+      "+": "+",
+      "?": "?",
+      "!": "!"
+    };
+    function escapeText(str) {
+      return str.replace(/[{}()\[\]+?!:*]/g, "\\$&");
+    }
+    function escape2(str) {
+      return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
+    }
+    function* lexer(str) {
+      const chars = [...str];
+      let i3 = 0;
+      function name() {
+        let value2 = "";
+        if (ID_START.test(chars[++i3])) {
+          value2 += chars[i3];
+          while (ID_CONTINUE.test(chars[++i3])) {
+            value2 += chars[i3];
+          }
+        } else if (chars[i3] === '"') {
+          let pos = i3;
+          while (i3 < chars.length) {
+            if (chars[++i3] === '"') {
+              i3++;
+              pos = 0;
+              break;
+            }
+            if (chars[i3] === "\\") {
+              value2 += chars[++i3];
+            } else {
+              value2 += chars[i3];
+            }
+          }
+          if (pos) {
+            throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);
+          }
+        }
+        if (!value2) {
+          throw new TypeError(`Missing parameter name at ${i3}: ${DEBUG_URL}`);
+        }
+        return value2;
+      }
+      while (i3 < chars.length) {
+        const value2 = chars[i3];
+        const type5 = SIMPLE_TOKENS[value2];
+        if (type5) {
+          yield { type: type5, index: i3++, value: value2 };
+        } else if (value2 === "\\") {
+          yield { type: "ESCAPED", index: i3++, value: chars[i3++] };
+        } else if (value2 === ":") {
+          const value3 = name();
+          yield { type: "PARAM", index: i3, value: value3 };
+        } else if (value2 === "*") {
+          const value3 = name();
+          yield { type: "WILDCARD", index: i3, value: value3 };
+        } else {
+          yield { type: "CHAR", index: i3, value: chars[i3++] };
+        }
+      }
+      return { type: "END", index: i3, value: "" };
+    }
+    var Iter = class {
+      constructor(tokens) {
+        this.tokens = tokens;
+      }
+      peek() {
+        if (!this._peek) {
+          const next2 = this.tokens.next();
+          this._peek = next2.value;
+        }
+        return this._peek;
+      }
+      tryConsume(type5) {
+        const token = this.peek();
+        if (token.type !== type5)
+          return;
+        this._peek = void 0;
+        return token.value;
+      }
+      consume(type5) {
+        const value2 = this.tryConsume(type5);
+        if (value2 !== void 0)
+          return value2;
+        const { type: nextType, index: index2 } = this.peek();
+        throw new TypeError(`Unexpected ${nextType} at ${index2}, expected ${type5}: ${DEBUG_URL}`);
+      }
+      text() {
+        let result = "";
+        let value2;
+        while (value2 = this.tryConsume("CHAR") || this.tryConsume("ESCAPED")) {
+          result += value2;
+        }
+        return result;
+      }
+    };
+    var TokenData = class {
+      constructor(tokens) {
+        this.tokens = tokens;
+      }
+    };
+    exports.TokenData = TokenData;
+    function parse4(str, options = {}) {
+      const { encodePath = NOOP_VALUE } = options;
+      const it = new Iter(lexer(str));
+      function consume(endType) {
+        const tokens2 = [];
+        while (true) {
+          const path3 = it.text();
+          if (path3)
+            tokens2.push({ type: "text", value: encodePath(path3) });
+          const param = it.tryConsume("PARAM");
+          if (param) {
+            tokens2.push({
+              type: "param",
+              name: param
+            });
+            continue;
+          }
+          const wildcard = it.tryConsume("WILDCARD");
+          if (wildcard) {
+            tokens2.push({
+              type: "wildcard",
+              name: wildcard
+            });
+            continue;
+          }
+          const open = it.tryConsume("{");
+          if (open) {
+            tokens2.push({
+              type: "group",
+              tokens: consume("}")
+            });
+            continue;
+          }
+          it.consume(endType);
+          return tokens2;
+        }
+      }
+      const tokens = consume("END");
+      return new TokenData(tokens);
+    }
+    function compile(path3, options = {}) {
+      const { encode: encode2 = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+      const data = path3 instanceof TokenData ? path3 : parse4(path3, options);
+      const fn = tokensToFunction(data.tokens, delimiter, encode2);
+      return function path4(data2 = {}) {
+        const [path5, ...missing] = fn(data2);
+        if (missing.length) {
+          throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
+        }
+        return path5;
+      };
+    }
+    function tokensToFunction(tokens, delimiter, encode2) {
+      const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode2));
+      return (data) => {
+        const result = [""];
+        for (const encoder of encoders) {
+          const [value2, ...extras] = encoder(data);
+          result[0] += value2;
+          result.push(...extras);
+        }
+        return result;
+      };
+    }
+    function tokenToFunction(token, delimiter, encode2) {
+      if (token.type === "text")
+        return () => [token.value];
+      if (token.type === "group") {
+        const fn = tokensToFunction(token.tokens, delimiter, encode2);
+        return (data) => {
+          const [value2, ...missing] = fn(data);
+          if (!missing.length)
+            return [value2];
+          return [""];
+        };
+      }
+      const encodeValue = encode2 || NOOP_VALUE;
+      if (token.type === "wildcard" && encode2 !== false) {
+        return (data) => {
+          const value2 = data[token.name];
+          if (value2 == null)
+            return ["", token.name];
+          if (!Array.isArray(value2) || value2.length === 0) {
+            throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
+          }
+          return [
+            value2.map((value3, index2) => {
+              if (typeof value3 !== "string") {
+                throw new TypeError(`Expected "${token.name}/${index2}" to be a string`);
+              }
+              return encodeValue(value3);
+            }).join(delimiter)
+          ];
+        };
+      }
+      return (data) => {
+        const value2 = data[token.name];
+        if (value2 == null)
+          return ["", token.name];
+        if (typeof value2 !== "string") {
+          throw new TypeError(`Expected "${token.name}" to be a string`);
+        }
+        return [encodeValue(value2)];
+      };
+    }
+    function match(path3, options = {}) {
+      const { decode: decode3 = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+      const { regexp, keys: keys2 } = pathToRegexp(path3, options);
+      const decoders = keys2.map((key2) => {
+        if (decode3 === false)
+          return NOOP_VALUE;
+        if (key2.type === "param")
+          return decode3;
+        return (value2) => value2.split(delimiter).map(decode3);
+      });
+      return function match2(input) {
+        const m2 = regexp.exec(input);
+        if (!m2)
+          return false;
+        const path4 = m2[0];
+        const params = /* @__PURE__ */ Object.create(null);
+        for (let i3 = 1; i3 < m2.length; i3++) {
+          if (m2[i3] === void 0)
+            continue;
+          const key2 = keys2[i3 - 1];
+          const decoder = decoders[i3 - 1];
+          params[key2.name] = decoder(m2[i3]);
+        }
+        return { path: path4, params };
+      };
+    }
+    function pathToRegexp(path3, options = {}) {
+      const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
+      const keys2 = [];
+      const sources = [];
+      const flags = sensitive ? "" : "i";
+      const paths = Array.isArray(path3) ? path3 : [path3];
+      const items = paths.map((path4) => path4 instanceof TokenData ? path4 : parse4(path4, options));
+      for (const { tokens } of items) {
+        for (const seq of flatten(tokens, 0, [])) {
+          const regexp2 = sequenceToRegExp(seq, delimiter, keys2);
+          sources.push(regexp2);
+        }
+      }
+      let pattern = `^(?:${sources.join("|")})`;
+      if (trailing)
+        pattern += `(?:${escape2(delimiter)}$)?`;
+      pattern += end ? "$" : `(?=${escape2(delimiter)}|$)`;
+      const regexp = new RegExp(pattern, flags);
+      return { regexp, keys: keys2 };
+    }
+    function* flatten(tokens, index2, init) {
+      if (index2 === tokens.length) {
+        return yield init;
+      }
+      const token = tokens[index2];
+      if (token.type === "group") {
+        const fork = init.slice();
+        for (const seq of flatten(token.tokens, 0, fork)) {
+          yield* flatten(tokens, index2 + 1, seq);
+        }
+      } else {
+        init.push(token);
+      }
+      yield* flatten(tokens, index2 + 1, init);
+    }
+    function sequenceToRegExp(tokens, delimiter, keys2) {
+      let result = "";
+      let backtrack = "";
+      let isSafeSegmentParam = true;
+      for (let i3 = 0; i3 < tokens.length; i3++) {
+        const token = tokens[i3];
+        if (token.type === "text") {
+          result += escape2(token.value);
+          backtrack += token.value;
+          isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+          continue;
+        }
+        if (token.type === "param" || token.type === "wildcard") {
+          if (!isSafeSegmentParam && !backtrack) {
+            throw new TypeError(`Missing text after "${token.name}": ${DEBUG_URL}`);
+          }
+          if (token.type === "param") {
+            result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
+          } else {
+            result += `([\\s\\S]+)`;
+          }
+          keys2.push(token);
+          backtrack = "";
+          isSafeSegmentParam = false;
+          continue;
+        }
+      }
+      return result;
+    }
+    function negate(delimiter, backtrack) {
+      if (backtrack.length < 2) {
+        if (delimiter.length < 2)
+          return `[^${escape2(delimiter + backtrack)}]`;
+        return `(?:(?!${escape2(delimiter)})[^${escape2(backtrack)}])`;
+      }
+      if (delimiter.length < 2) {
+        return `(?:(?!${escape2(backtrack)})[^${escape2(delimiter)}])`;
+      }
+      return `(?:(?!${escape2(backtrack)}|${escape2(delimiter)})[\\s\\S])`;
+    }
+    function stringify5(data) {
+      return data.tokens.map(function stringifyToken(token, index2, tokens) {
+        if (token.type === "text")
+          return escapeText(token.value);
+        if (token.type === "group") {
+          return `{${token.tokens.map(stringifyToken).join("")}}`;
+        }
+        const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index2 + 1]);
+        const key2 = isSafe ? token.name : JSON.stringify(token.name);
+        if (token.type === "param")
+          return `:${key2}`;
+        if (token.type === "wildcard")
+          return `*${key2}`;
+        throw new TypeError(`Unexpected token: ${token}`);
+      }).join("");
+    }
+    function isNameSafe(name) {
+      const [first, ...rest] = name;
+      if (!ID_START.test(first))
+        return false;
+      return rest.every((char) => ID_CONTINUE.test(char));
+    }
+    function isNextNameSafe(token) {
+      if ((token === null || token === void 0 ? void 0 : token.type) !== "text")
+        return true;
+      return !ID_CONTINUE.test(token.value[0]);
+    }
+  }
+});
+
 // node_modules/.pnpm/@pushrocks+smartpromise@3.1.10/node_modules/@pushrocks/smartpromise/dist_ts/index.js
 var require_dist_ts3 = __commonJS({
   "node_modules/.pnpm/@pushrocks+smartpromise@3.1.10/node_modules/@pushrocks/smartpromise/dist_ts/index.js"(exports) {
@@ -11955,9 +12318,9 @@ CronDate.prototype.findNext = function(options, target, pattern, offset) {
   }
   const fDomWeekDay = !pattern.starDOW && target == "day" ? new Date(Date.UTC(this.year, this.month, 1, 0, 0, 0, 0)).getUTCDay() : void 0;
   for (let i3 = this[target] + offset; i3 < pattern[target].length; i3++) {
-    let match2 = pattern[target][i3];
+    let match = pattern[target][i3];
     if (target === "day" && pattern.lastDayOfMonth && i3 - offset == lastDayOfMonth) {
-      match2 = true;
+      match = true;
     }
     if (target === "day" && !pattern.starDOW) {
       let dowMatch = pattern.dayOfWeek[(fDomWeekDay + (i3 - offset - 1)) % 7];
@@ -11967,12 +12330,12 @@ CronDate.prototype.findNext = function(options, target, pattern, offset) {
         throw new Error(`CronDate: Invalid value for dayOfWeek encountered. ${dowMatch}`);
       }
       if (options.legacyMode && !pattern.starDOM) {
-        match2 = match2 || dowMatch;
+        match = match || dowMatch;
       } else {
-        match2 = match2 && dowMatch;
+        match = match && dowMatch;
       }
     }
-    if (match2) {
+    if (match) {
       this[target] = i3 - offset;
       return originalTarget !== this[target] ? 2 : 1;
     }
@@ -18806,15 +19169,15 @@ function findAndReplace(tree, list5, options) {
     let change = false;
     let nodes = [];
     find2.lastIndex = 0;
-    let match2 = find2.exec(node2.value);
-    while (match2) {
-      const position3 = match2.index;
+    let match = find2.exec(node2.value);
+    while (match) {
+      const position3 = match.index;
       const matchObject = {
-        index: match2.index,
-        input: match2.input,
+        index: match.index,
+        input: match.input,
         stack: [...parents, node2]
       };
-      let value2 = replace2(...match2, matchObject);
+      let value2 = replace2(...match, matchObject);
       if (typeof value2 === "string") {
         value2 = value2.length > 0 ? { type: "text", value: value2 } : void 0;
       }
@@ -18832,13 +19195,13 @@ function findAndReplace(tree, list5, options) {
         } else if (value2) {
           nodes.push(value2);
         }
-        start = position3 + match2[0].length;
+        start = position3 + match[0].length;
         change = true;
       }
       if (!find2.global) {
         break;
       }
-      match2 = find2.exec(node2.value);
+      match = find2.exec(node2.value);
     }
     if (change) {
       if (start < node2.value.length) {
@@ -18951,9 +19314,9 @@ function transformGfmAutolinkLiterals(tree) {
     { ignore: ["link", "linkReference"] }
   );
 }
-function findUrl(_2, protocol, domain2, path3, match2) {
+function findUrl(_2, protocol, domain2, path3, match) {
   let prefix = "";
-  if (!previous(match2)) {
+  if (!previous(match)) {
     return false;
   }
   if (/^w/i.test(protocol)) {
@@ -18978,10 +19341,10 @@ function findUrl(_2, protocol, domain2, path3, match2) {
   }
   return result;
 }
-function findEmail(_2, atext, label, match2) {
+function findEmail(_2, atext, label, match) {
   if (
     // Not an expected previous character.
-    !previous(match2, true) || // Label ends in not allowed character.
+    !previous(match, true) || // Label ends in not allowed character.
     /[-\d_]$/.test(label)
   ) {
     return false;
@@ -19018,9 +19381,9 @@ function splitUrl(url2) {
   }
   return [url2, trail2];
 }
-function previous(match2, email) {
-  const code4 = match2.input.charCodeAt(match2.index - 1);
-  return (match2.index === 0 || unicodeWhitespace(code4) || unicodePunctuation(code4)) && (!email || code4 !== 47);
+function previous(match, email) {
+  const code4 = match.input.charCodeAt(match.index - 1);
+  return (match.index === 0 || unicodeWhitespace(code4) || unicodePunctuation(code4)) && (!email || code4 !== 47);
 }
 
 // node_modules/.pnpm/micromark-util-normalize-identifier@2.0.0/node_modules/micromark-util-normalize-identifier/index.js
@@ -19882,15 +20245,15 @@ function inlineCode(node2, _2, state) {
   while (++index2 < state.unsafe.length) {
     const pattern = state.unsafe[index2];
     const expression = state.compilePattern(pattern);
-    let match2;
+    let match;
     if (!pattern.atBreak)
       continue;
-    while (match2 = expression.exec(value2)) {
-      let position3 = match2.index;
+    while (match = expression.exec(value2)) {
+      let position3 = match.index;
       if (value2.charCodeAt(position3) === 10 && value2.charCodeAt(position3 - 1) === 13) {
         position3--;
       }
-      value2 = value2.slice(0, position3) + " " + value2.slice(match2.index + 1);
+      value2 = value2.slice(0, position3) + " " + value2.slice(match.index + 1);
     }
   }
   return sequence + value2 + sequence;
@@ -20614,11 +20977,11 @@ function indentLines(value2, map8) {
   const result = [];
   let start = 0;
   let line = 0;
-  let match2;
-  while (match2 = eol.exec(value2)) {
-    one3(value2.slice(start, match2.index));
-    result.push(match2[0]);
-    start = match2.index + match2[0].length;
+  let match;
+  while (match = eol.exec(value2)) {
+    one3(value2.slice(start, match.index));
+    result.push(match[0]);
+    start = match.index + match[0].length;
     line++;
   }
   one3(value2.slice(start));
@@ -20641,11 +21004,11 @@ function safe(state, input, config2) {
       continue;
     }
     const expression = state.compilePattern(pattern);
-    let match2;
-    while (match2 = expression.exec(value2)) {
+    let match;
+    while (match = expression.exec(value2)) {
       const before = "before" in pattern || Boolean(pattern.atBreak);
       const after = "after" in pattern;
-      const position3 = match2.index + (before ? match2[1].length : 0);
+      const position3 = match.index + (before ? match[1].length : 0);
       if (positions.includes(position3)) {
         if (infos[position3].before && !before) {
           infos[position3].before = false;
@@ -20697,9 +21060,9 @@ function escapeBackslashes(value2, after) {
   const whole = value2 + after;
   let index2 = -1;
   let start = 0;
-  let match2;
-  while (match2 = expression.exec(whole)) {
-    positions.push(match2.index);
+  let match;
+  while (match = expression.exec(whole)) {
+    positions.push(match.index);
   }
   while (++index2 < positions.length) {
     if (start !== positions[index2]) {
@@ -26351,7 +26714,7 @@ function preprocess() {
   return preprocessor;
   function preprocessor(value2, encoding, end) {
     const chunks = [];
-    let match2;
+    let match;
     let next2;
     let startPosition;
     let endPosition;
@@ -26367,10 +26730,10 @@ function preprocess() {
     }
     while (startPosition < value2.length) {
       search.lastIndex = startPosition;
-      match2 = search.exec(value2);
-      endPosition = match2 && match2.index !== void 0 ? match2.index : value2.length;
+      match = search.exec(value2);
+      endPosition = match && match.index !== void 0 ? match.index : value2.length;
       code4 = value2.charCodeAt(endPosition);
-      if (!match2) {
+      if (!match) {
         buffer = value2.slice(startPosition);
         break;
       }
@@ -26533,8 +26896,8 @@ function compiler(options) {
   };
   configure2(config2, (options || {}).mdastExtensions || []);
   const data = {};
-  return compile2;
-  function compile2(events) {
+  return compile;
+  function compile(events) {
     let tree = {
       type: "root",
       children: []
@@ -27521,8 +27884,8 @@ var deserializer = ($2, _2) => {
       case DATE:
         return as(new Date(value2), index2);
       case REGEXP: {
-        const { source, flags: flags2 } = value2;
-        return as(new RegExp(source, flags2), index2);
+        const { source, flags } = value2;
+        return as(new RegExp(source, flags), index2);
       }
       case MAP: {
         const map8 = as(/* @__PURE__ */ new Map(), index2);
@@ -27643,8 +28006,8 @@ var serializer = (strict, json, $2, _2) => {
       case DATE:
         return as([TYPE, value2.toISOString()], value2);
       case REGEXP: {
-        const { source, flags: flags2 } = value2;
-        return as([TYPE, { source, flags: flags2 }], value2);
+        const { source, flags } = value2;
+        return as([TYPE, { source, flags }], value2);
       }
       case MAP: {
         const entries = [];
@@ -28619,16 +28982,16 @@ var space = 32;
 function trimLines(value2) {
   const source = String(value2);
   const search2 = /\r?\n|\r/g;
-  let match2 = search2.exec(source);
+  let match = search2.exec(source);
   let last2 = 0;
   const lines = [];
-  while (match2) {
+  while (match) {
     lines.push(
-      trimLine(source.slice(last2, match2.index), last2 > 0, true),
-      match2[0]
+      trimLine(source.slice(last2, match.index), last2 > 0, true),
+      match[0]
     );
-    last2 = match2.index + match2[0].length;
-    match2 = search2.exec(source);
+    last2 = match.index + match[0].length;
+    match = search2.exec(source);
   }
   lines.push(trimLine(source.slice(last2), last2 > 0, false));
   return lines.join("");
@@ -31377,10 +31740,10 @@ rules.fencedCodeBlock = {
     var fenceChar = options.fence.charAt(0);
     var fenceSize = 3;
     var fenceInCodeRegex = new RegExp("^" + fenceChar + "{3,}", "gm");
-    var match2;
-    while (match2 = fenceInCodeRegex.exec(code4)) {
-      if (match2[0].length >= fenceSize) {
-        fenceSize = match2[0].length + 1;
+    var match;
+    while (match = fenceInCodeRegex.exec(code4)) {
+      if (match[0].length >= fenceSize) {
+        fenceSize = match[0].length + 1;
       }
     }
     var fence3 = repeat(fenceChar, fenceSize);
@@ -32105,383 +32468,16 @@ var SmartMarkdown = class _SmartMarkdown {
   }
 };
 
-// node_modules/.pnpm/@push.rocks+smartrouter@1.0.16/node_modules/@push.rocks/smartrouter/dist_ts/index.js
+// node_modules/.pnpm/@push.rocks+smartrouter@1.3.2/node_modules/@push.rocks/smartrouter/dist_ts/index.js
 var dist_ts_exports18 = {};
 __export(dist_ts_exports18, {
   SmartRouter: () => SmartRouter
 });
 
-// node_modules/.pnpm/path-to-regexp@6.2.2/node_modules/path-to-regexp/dist.es2015/index.js
-var dist_exports = {};
-__export(dist_exports, {
-  compile: () => compile,
-  match: () => match,
-  parse: () => parse4,
-  pathToRegexp: () => pathToRegexp,
-  regexpToFunction: () => regexpToFunction,
-  tokensToFunction: () => tokensToFunction,
-  tokensToRegexp: () => tokensToRegexp
-});
-function lexer(str) {
-  var tokens = [];
-  var i3 = 0;
-  while (i3 < str.length) {
-    var char = str[i3];
-    if (char === "*" || char === "+" || char === "?") {
-      tokens.push({ type: "MODIFIER", index: i3, value: str[i3++] });
-      continue;
-    }
-    if (char === "\\") {
-      tokens.push({ type: "ESCAPED_CHAR", index: i3++, value: str[i3++] });
-      continue;
-    }
-    if (char === "{") {
-      tokens.push({ type: "OPEN", index: i3, value: str[i3++] });
-      continue;
-    }
-    if (char === "}") {
-      tokens.push({ type: "CLOSE", index: i3, value: str[i3++] });
-      continue;
-    }
-    if (char === ":") {
-      var name = "";
-      var j2 = i3 + 1;
-      while (j2 < str.length) {
-        var code4 = str.charCodeAt(j2);
-        if (
-          // `0-9`
-          code4 >= 48 && code4 <= 57 || // `A-Z`
-          code4 >= 65 && code4 <= 90 || // `a-z`
-          code4 >= 97 && code4 <= 122 || // `_`
-          code4 === 95
-        ) {
-          name += str[j2++];
-          continue;
-        }
-        break;
-      }
-      if (!name)
-        throw new TypeError("Missing parameter name at ".concat(i3));
-      tokens.push({ type: "NAME", index: i3, value: name });
-      i3 = j2;
-      continue;
-    }
-    if (char === "(") {
-      var count = 1;
-      var pattern = "";
-      var j2 = i3 + 1;
-      if (str[j2] === "?") {
-        throw new TypeError('Pattern cannot start with "?" at '.concat(j2));
-      }
-      while (j2 < str.length) {
-        if (str[j2] === "\\") {
-          pattern += str[j2++] + str[j2++];
-          continue;
-        }
-        if (str[j2] === ")") {
-          count--;
-          if (count === 0) {
-            j2++;
-            break;
-          }
-        } else if (str[j2] === "(") {
-          count++;
-          if (str[j2 + 1] !== "?") {
-            throw new TypeError("Capturing groups are not allowed at ".concat(j2));
-          }
-        }
-        pattern += str[j2++];
-      }
-      if (count)
-        throw new TypeError("Unbalanced pattern at ".concat(i3));
-      if (!pattern)
-        throw new TypeError("Missing pattern at ".concat(i3));
-      tokens.push({ type: "PATTERN", index: i3, value: pattern });
-      i3 = j2;
-      continue;
-    }
-    tokens.push({ type: "CHAR", index: i3, value: str[i3++] });
-  }
-  tokens.push({ type: "END", index: i3, value: "" });
-  return tokens;
-}
-function parse4(str, options) {
-  if (options === void 0) {
-    options = {};
-  }
-  var tokens = lexer(str);
-  var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a;
-  var defaultPattern = "[^".concat(escapeString(options.delimiter || "/#?"), "]+?");
-  var result = [];
-  var key2 = 0;
-  var i3 = 0;
-  var path3 = "";
-  var tryConsume = function(type5) {
-    if (i3 < tokens.length && tokens[i3].type === type5)
-      return tokens[i3++].value;
-  };
-  var mustConsume = function(type5) {
-    var value3 = tryConsume(type5);
-    if (value3 !== void 0)
-      return value3;
-    var _a2 = tokens[i3], nextType = _a2.type, index2 = _a2.index;
-    throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index2, ", expected ").concat(type5));
-  };
-  var consumeText = function() {
-    var result2 = "";
-    var value3;
-    while (value3 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
-      result2 += value3;
-    }
-    return result2;
-  };
-  while (i3 < tokens.length) {
-    var char = tryConsume("CHAR");
-    var name = tryConsume("NAME");
-    var pattern = tryConsume("PATTERN");
-    if (name || pattern) {
-      var prefix = char || "";
-      if (prefixes.indexOf(prefix) === -1) {
-        path3 += prefix;
-        prefix = "";
-      }
-      if (path3) {
-        result.push(path3);
-        path3 = "";
-      }
-      result.push({
-        name: name || key2++,
-        prefix,
-        suffix: "",
-        pattern: pattern || defaultPattern,
-        modifier: tryConsume("MODIFIER") || ""
-      });
-      continue;
-    }
-    var value2 = char || tryConsume("ESCAPED_CHAR");
-    if (value2) {
-      path3 += value2;
-      continue;
-    }
-    if (path3) {
-      result.push(path3);
-      path3 = "";
-    }
-    var open = tryConsume("OPEN");
-    if (open) {
-      var prefix = consumeText();
-      var name_1 = tryConsume("NAME") || "";
-      var pattern_1 = tryConsume("PATTERN") || "";
-      var suffix = consumeText();
-      mustConsume("CLOSE");
-      result.push({
-        name: name_1 || (pattern_1 ? key2++ : ""),
-        pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
-        prefix,
-        suffix,
-        modifier: tryConsume("MODIFIER") || ""
-      });
-      continue;
-    }
-    mustConsume("END");
-  }
-  return result;
-}
-function compile(str, options) {
-  return tokensToFunction(parse4(str, options), options);
-}
-function tokensToFunction(tokens, options) {
-  if (options === void 0) {
-    options = {};
-  }
-  var reFlags = flags(options);
-  var _a = options.encode, encode2 = _a === void 0 ? function(x2) {
-    return x2;
-  } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;
-  var matches = tokens.map(function(token) {
-    if (typeof token === "object") {
-      return new RegExp("^(?:".concat(token.pattern, ")$"), reFlags);
-    }
-  });
-  return function(data) {
-    var path3 = "";
-    for (var i3 = 0; i3 < tokens.length; i3++) {
-      var token = tokens[i3];
-      if (typeof token === "string") {
-        path3 += token;
-        continue;
-      }
-      var value2 = data ? data[token.name] : void 0;
-      var optional = token.modifier === "?" || token.modifier === "*";
-      var repeat2 = token.modifier === "*" || token.modifier === "+";
-      if (Array.isArray(value2)) {
-        if (!repeat2) {
-          throw new TypeError('Expected "'.concat(token.name, '" to not repeat, but got an array'));
-        }
-        if (value2.length === 0) {
-          if (optional)
-            continue;
-          throw new TypeError('Expected "'.concat(token.name, '" to not be empty'));
-        }
-        for (var j2 = 0; j2 < value2.length; j2++) {
-          var segment = encode2(value2[j2], token);
-          if (validate && !matches[i3].test(segment)) {
-            throw new TypeError('Expected all "'.concat(token.name, '" to match "').concat(token.pattern, '", but got "').concat(segment, '"'));
-          }
-          path3 += token.prefix + segment + token.suffix;
-        }
-        continue;
-      }
-      if (typeof value2 === "string" || typeof value2 === "number") {
-        var segment = encode2(String(value2), token);
-        if (validate && !matches[i3].test(segment)) {
-          throw new TypeError('Expected "'.concat(token.name, '" to match "').concat(token.pattern, '", but got "').concat(segment, '"'));
-        }
-        path3 += token.prefix + segment + token.suffix;
-        continue;
-      }
-      if (optional)
-        continue;
-      var typeOfMessage = repeat2 ? "an array" : "a string";
-      throw new TypeError('Expected "'.concat(token.name, '" to be ').concat(typeOfMessage));
-    }
-    return path3;
-  };
-}
-function match(str, options) {
-  var keys2 = [];
-  var re2 = pathToRegexp(str, keys2, options);
-  return regexpToFunction(re2, keys2, options);
-}
-function regexpToFunction(re2, keys2, options) {
-  if (options === void 0) {
-    options = {};
-  }
-  var _a = options.decode, decode3 = _a === void 0 ? function(x2) {
-    return x2;
-  } : _a;
-  return function(pathname) {
-    var m2 = re2.exec(pathname);
-    if (!m2)
-      return false;
-    var path3 = m2[0], index2 = m2.index;
-    var params = /* @__PURE__ */ Object.create(null);
-    var _loop_1 = function(i4) {
-      if (m2[i4] === void 0)
-        return "continue";
-      var key2 = keys2[i4 - 1];
-      if (key2.modifier === "*" || key2.modifier === "+") {
-        params[key2.name] = m2[i4].split(key2.prefix + key2.suffix).map(function(value2) {
-          return decode3(value2, key2);
-        });
-      } else {
-        params[key2.name] = decode3(m2[i4], key2);
-      }
-    };
-    for (var i3 = 1; i3 < m2.length; i3++) {
-      _loop_1(i3);
-    }
-    return { path: path3, index: index2, params };
-  };
-}
-function escapeString(str) {
-  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
-}
-function flags(options) {
-  return options && options.sensitive ? "" : "i";
-}
-function regexpToRegexp(path3, keys2) {
-  if (!keys2)
-    return path3;
-  var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
-  var index2 = 0;
-  var execResult = groupsRegex.exec(path3.source);
-  while (execResult) {
-    keys2.push({
-      // Use parenthesized substring match if available, index otherwise
-      name: execResult[1] || index2++,
-      prefix: "",
-      suffix: "",
-      modifier: "",
-      pattern: ""
-    });
-    execResult = groupsRegex.exec(path3.source);
-  }
-  return path3;
-}
-function arrayToRegexp(paths, keys2, options) {
-  var parts = paths.map(function(path3) {
-    return pathToRegexp(path3, keys2, options).source;
-  });
-  return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
-}
-function stringToRegexp(path3, keys2, options) {
-  return tokensToRegexp(parse4(path3, options), keys2, options);
-}
-function tokensToRegexp(tokens, keys2, options) {
-  if (options === void 0) {
-    options = {};
-  }
-  var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode2 = _d === void 0 ? function(x2) {
-    return x2;
-  } : _d, _e = options.delimiter, delimiter = _e === void 0 ? "/#?" : _e, _f = options.endsWith, endsWith = _f === void 0 ? "" : _f;
-  var endsWithRe = "[".concat(escapeString(endsWith), "]|$");
-  var delimiterRe = "[".concat(escapeString(delimiter), "]");
-  var route = start ? "^" : "";
-  for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
-    var token = tokens_1[_i];
-    if (typeof token === "string") {
-      route += escapeString(encode2(token));
-    } else {
-      var prefix = escapeString(encode2(token.prefix));
-      var suffix = escapeString(encode2(token.suffix));
-      if (token.pattern) {
-        if (keys2)
-          keys2.push(token);
-        if (prefix || suffix) {
-          if (token.modifier === "+" || token.modifier === "*") {
-            var mod = token.modifier === "*" ? "?" : "";
-            route += "(?:".concat(prefix, "((?:").concat(token.pattern, ")(?:").concat(suffix).concat(prefix, "(?:").concat(token.pattern, "))*)").concat(suffix, ")").concat(mod);
-          } else {
-            route += "(?:".concat(prefix, "(").concat(token.pattern, ")").concat(suffix, ")").concat(token.modifier);
-          }
-        } else {
-          if (token.modifier === "+" || token.modifier === "*") {
-            route += "((?:".concat(token.pattern, ")").concat(token.modifier, ")");
-          } else {
-            route += "(".concat(token.pattern, ")").concat(token.modifier);
-          }
-        }
-      } else {
-        route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier);
-      }
-    }
-  }
-  if (end) {
-    if (!strict)
-      route += "".concat(delimiterRe, "?");
-    route += !options.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
-  } else {
-    var endToken = tokens[tokens.length - 1];
-    var isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
-    if (!strict) {
-      route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
-    }
-    if (!isEndDelimited) {
-      route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
-    }
-  }
-  return new RegExp(route, flags(options));
-}
-function pathToRegexp(path3, keys2, options) {
-  if (path3 instanceof RegExp)
-    return regexpToRegexp(path3, keys2);
-  if (Array.isArray(path3))
-    return arrayToRegexp(path3, keys2, options);
-  return stringToRegexp(path3, keys2, options);
-}
+// node_modules/.pnpm/@push.rocks+smartrouter@1.3.2/node_modules/@push.rocks/smartrouter/dist_ts/smartrouter.plugins.js
+var pathToRegExp = __toESM(require_dist(), 1);
 
-// node_modules/.pnpm/@push.rocks+smartrouter@1.0.16/node_modules/@push.rocks/smartrouter/dist_ts/smartrouter.classes.queryparams.js
+// node_modules/.pnpm/@push.rocks+smartrouter@1.3.2/node_modules/@push.rocks/smartrouter/dist_ts/smartrouter.classes.queryparams.js
 var QueryParams = class {
   constructor() {
   }
@@ -32505,12 +32501,12 @@ var QueryParams = class {
   }
 };
 
-// node_modules/.pnpm/@push.rocks+smartrouter@1.0.16/node_modules/@push.rocks/smartrouter/dist_ts/smartrouter.classes.smartrouter.js
-var SmartRouter = class {
+// node_modules/.pnpm/@push.rocks+smartrouter@1.3.2/node_modules/@push.rocks/smartrouter/dist_ts/smartrouter.classes.smartrouter.js
+var SmartRouter = class _SmartRouter {
   /**
    * Creates an instance of Router.
    */
-  constructor(optionsArg) {
+  constructor(optionsArg, basePath = "") {
     this.options = {
       debug: false
     };
@@ -32520,19 +32516,31 @@ var SmartRouter = class {
       ...this.options,
       ...optionsArg
     };
-    window.addEventListener("popstate", (popStateEventArg) => {
+    this.basePath = basePath;
+    this.popstateListener = (popStateEventArg) => {
       popStateEventArg.preventDefault();
       this._handleRouteState();
-    });
+    };
+    window.addEventListener("popstate", this.popstateListener);
+  }
+  /**
+   * Create a sub-router with a specific prefix
+   * @param {string} subPath
+   * @param {IRouterOptions} [options]
+   */
+  createSubRouter(subPath, options) {
+    const newBasePath = `${this.basePath}${subPath}`;
+    return new _SmartRouter({ ...this.options, ...options }, newBasePath);
   }
   /**
    * Push route state to history stack
    */
   async pushUrl(url2 = "/", state = {}) {
-    if (url2 !== window.location.pathname) {
-      window.history.pushState(state, window.document.title, url2);
+    const fullUrl = `${this.basePath}${url2}`;
+    if (fullUrl !== window.location.pathname) {
+      window.history.pushState(state, window.document.title, fullUrl);
     } else {
-      window.history.replaceState(state, window.document.title, url2);
+      window.history.replaceState(state, window.document.title, fullUrl);
     }
     await this._handleRouteState();
   }
@@ -32542,10 +32550,16 @@ var SmartRouter = class {
    * @param {function} handlerArg
    */
   on(routeArg, handlerArg) {
-    this.routes.push({
-      matchFunction: dist_exports.match(routeArg),
+    const fullRoute = `${this.basePath}${routeArg}`;
+    const routeObject = {
+      matchFunction: pathToRegExp.match(fullRoute),
       handler: handlerArg
-    });
+    };
+    this.routes.push(routeObject);
+    const removeFunction = () => {
+      this.routes.splice(this.routes.indexOf(routeObject), 1);
+    };
+    return removeFunction;
   }
   /**
    * Apply routes handler to current route
@@ -32564,9 +32578,16 @@ var SmartRouter = class {
       });
     }
   }
+  /**
+   * Destroy the router instance, removing all external references
+   */
+  destroy() {
+    window.removeEventListener("popstate", this.popstateListener);
+    this.routes = [];
+  }
 };
 
-// node_modules/.pnpm/@push.rocks+smartstate@2.0.18/node_modules/@push.rocks/smartstate/dist_ts/index.js
+// node_modules/.pnpm/@push.rocks+smartstate@2.0.19/node_modules/@push.rocks/smartstate/dist_ts/index.js
 var dist_ts_exports21 = {};
 __export(dist_ts_exports21, {
   Smartstate: () => Smartstate,
@@ -32736,7 +32757,7 @@ var sha256FromString = async (stringArg) => {
   }
 };
 
-// node_modules/.pnpm/@push.rocks+smartstate@2.0.18/node_modules/@push.rocks/smartstate/dist_ts/smartstate.classes.stateaction.js
+// node_modules/.pnpm/@push.rocks+smartstate@2.0.19/node_modules/@push.rocks/smartstate/dist_ts/smartstate.classes.stateaction.js
 var StateAction = class {
   constructor(statePartRef, actionDef) {
     this.statePartRef = statePartRef;
@@ -32747,7 +32768,7 @@ var StateAction = class {
   }
 };
 
-// node_modules/.pnpm/@push.rocks+smartstate@2.0.18/node_modules/@push.rocks/smartstate/dist_ts/smartstate.classes.statepart.js
+// node_modules/.pnpm/@push.rocks+smartstate@2.0.19/node_modules/@push.rocks/smartstate/dist_ts/smartstate.classes.statepart.js
 var StatePart = class {
   constructor(nameArg, webStoreOptionsArg) {
     this.state = new dist_ts_exports4.rxjs.Subject();
@@ -32866,7 +32887,7 @@ var StatePart = class {
   }
 };
 
-// node_modules/.pnpm/@push.rocks+smartstate@2.0.18/node_modules/@push.rocks/smartstate/dist_ts/smartstate.classes.smartstate.js
+// node_modules/.pnpm/@push.rocks+smartstate@2.0.19/node_modules/@push.rocks/smartstate/dist_ts/smartstate.classes.smartstate.js
 var Smartstate = class {
   constructor() {
     this.statePartMap = {};
@@ -32914,14 +32935,15 @@ var Smartstate = class {
   }
 };
 
-// node_modules/.pnpm/@push.rocks+smarturl@3.0.7/node_modules/@push.rocks/smarturl/dist_ts/index.js
+// node_modules/.pnpm/@push.rocks+smarturl@3.1.0/node_modules/@push.rocks/smarturl/dist_ts/index.js
 var dist_ts_exports22 = {};
 __export(dist_ts_exports22, {
   Smarturl: () => Smarturl
 });
 
-// node_modules/.pnpm/@push.rocks+smarturl@3.0.7/node_modules/@push.rocks/smarturl/dist_ts/smarturl.classes.smarturl.js
+// node_modules/.pnpm/@push.rocks+smarturl@3.1.0/node_modules/@push.rocks/smarturl/dist_ts/smarturl.classes.smarturl.js
 var Smarturl = class _Smarturl {
+  // Static method to create a Smarturl instance from a URL string
   static createFromUrl(urlArg, optionsArg) {
     const parsedUrlInstance = new URL(urlArg);
     const searchParams = {};
@@ -32981,14 +33003,34 @@ var Smarturl = class _Smarturl {
     Object.assign(returnSmarturl, parsedUrl);
     return returnSmarturl;
   }
+  // Static method to create a Smarturl instance from an existing IUrlObject
   static createFromParsedUrl(parsedUrlArg) {
     const returnSmarturl = new _Smarturl();
     Object.assign(returnSmarturl, parsedUrlArg);
     return returnSmarturl;
   }
+  // Constructor initializes searchParams as an empty object
   constructor() {
     this.searchParams = {};
   }
+  // Method to create an independent clone of the current Smarturl instance
+  clone() {
+    const clonedInstance = new _Smarturl();
+    Object.assign(clonedInstance, this);
+    clonedInstance.searchParams = { ...this.searchParams };
+    return clonedInstance;
+  }
+  /**
+   * Typed method to set a property and return the instance for chaining.
+   * @param prop - The property name to set (must be a key of Smarturl)
+   * @param value - The value to assign to the property
+   * @returns The Smarturl instance for method chaining
+   */
+  set(prop, value2) {
+    this[prop] = value2;
+    return this;
+  }
+  // Method to convert the Smarturl instance back into a URL string
   toString() {
     let userpart = ``;
     if (this.username && !this.password) {