@nebula-spatial/viewer 0.4.3 → 0.4.5

package/dist/xacro-DrBtv-gK.js

@@ -0,0 +1,1537 @@
+import { n as bt } from "./session-DNyPmQOW.js";
+function _t(t) {
+  const e = t.split(/[\\/]/g);
+  return e.pop(), e.length === 0 ? "./" : e.join("/") + "/";
+}
+function K(t, e, r = []) {
+  t.tagName === e && r.push(t);
+  for (let n = 0, s = t.children.length; n < s; n++) {
+    const o = t.children[n];
+    K(o, e, r);
+  }
+  return r;
+}
+function ft(t, e) {
+  const r = t.cloneNode(), n = t.childNodes;
+  for (let s = 0, o = n.length; s < o; s++) {
+    const a = n[s], u = a.tagName;
+    (!e || u !== "xacro:property" && u !== "xacro:macro") && r.appendChild(ft(a, e));
+  }
+  return r;
+}
+function rt(t) {
+  for (; t.length > 0; ) {
+    const e = t[t.length - 1];
+    if (e.nodeType !== e.ELEMENT_NODE)
+      t.pop();
+    else
+      break;
+  }
+}
+function Zt(t) {
+  return /^[()/*+\-%|&=[\]]+$/.test(t);
+}
+function jt(t) {
+  return /^(('[^']*?')|("[^"]*?")|(`[^`]*?`))$/.test(t);
+}
+function gt(t) {
+  return !isNaN(Number(t)) && !isNaN(parseFloat(t));
+}
+function Jt(t) {
+  const e = /(('[^']*?')|("[^"]*?")|(`[^`]*?`)|([()/*+\-%|!&=]+?))/g;
+  return t.replace(e, (r) => ` ${r} `).trim().split(/\s+/g);
+}
+function Qt(t) {
+  return t.replace(/[-+]{2,}/, (e) => {
+    let r = !0;
+    for (let n = 0, s = e.length; n < s; n++)
+      e[n] === "-" && (r = !r);
+    return r ? "+" : "-";
+  });
+}
+const st = Symbol("parent");
+function Tt(...t) {
+  const e = {};
+  for (let r = 0, n = t.length; r < n; r++) {
+    const s = t[r];
+    for (const o in s)
+      e[o] = s[o];
+    st in s && (e[st] = s[st]);
+  }
+  return e;
+}
+function te(t) {
+  const e = Tt(t);
+  return e[st] = t, e;
+}
+var X = "INUMBER", ut = "IOP1", ht = "IOP2", ct = "IOP3", z = "IVAR", H = "IVARNAME", at = "IFUNCALL", yt = "IFUNDEF", F = "IEXPR", Nt = "IEXPREVAL", Z = "IMEMBER", xt = "IENDSTATEMENT", ot = "IARRAY";
+function x(t, e) {
+  this.type = t, this.value = e ?? 0;
+}
+x.prototype.toString = function() {
+  switch (this.type) {
+    case X:
+    case ut:
+    case ht:
+    case ct:
+    case z:
+    case H:
+    case xt:
+      return this.value;
+    case at:
+      return "CALL " + this.value;
+    case yt:
+      return "DEF " + this.value;
+    case ot:
+      return "ARRAY " + this.value;
+    case Z:
+      return "." + this.value;
+    default:
+      return "Invalid Instruction";
+  }
+};
+function Mt(t) {
+  return new x(ut, t);
+}
+function G(t) {
+  return new x(ht, t);
+}
+function Wt(t) {
+  return new x(ct, t);
+}
+function Pt(t, e, r, n, s) {
+  for (var o = [], a = [], u, y, M, E, N = 0; N < t.length; N++) {
+    var c = t[N], b = c.type;
+    if (b === X || b === H)
+      Array.isArray(c.value) ? o.push.apply(o, Pt(c.value.map(function(R) {
+        return new x(X, R);
+      }).concat(new x(ot, c.value.length)), e, r, n, s)) : o.push(c);
+    else if (b === z && Object.hasOwn(s, c.value))
+      c = new x(X, s[c.value]), o.push(c);
+    else if (b === ht && o.length > 1)
+      y = o.pop(), u = o.pop(), E = r[c.value], c = new x(X, E(u.value, y.value)), o.push(c);
+    else if (b === ct && o.length > 2)
+      M = o.pop(), y = o.pop(), u = o.pop(), c.value === "?" ? o.push(u.value ? y.value : M.value) : (E = n[c.value], c = new x(X, E(u.value, y.value, M.value)), o.push(c));
+    else if (b === ut && o.length > 0)
+      u = o.pop(), E = e[c.value], c = new x(X, E(u.value)), o.push(c);
+    else if (b === F) {
+      for (; o.length > 0; )
+        a.push(o.shift());
+      a.push(new x(F, Pt(c.value, e, r, n, s)));
+    } else if (b === Z && o.length > 0)
+      u = o.pop(), o.push(new x(X, u.value[c.value]));
+    else {
+      for (; o.length > 0; )
+        a.push(o.shift());
+      a.push(c);
+    }
+  }
+  for (; o.length > 0; )
+    a.push(o.shift());
+  return a;
+}
+function Gt(t, e, r) {
+  for (var n = [], s = 0; s < t.length; s++) {
+    var o = t[s], a = o.type;
+    if (a === z && o.value === e)
+      for (var u = 0; u < r.tokens.length; u++) {
+        var y = r.tokens[u], M;
+        y.type === ut ? M = Mt(y.value) : y.type === ht ? M = G(y.value) : y.type === ct ? M = Wt(y.value) : M = new x(y.type, y.value), n.push(M);
+      }
+    else a === F ? n.push(new x(F, Gt(o.value, e, r))) : n.push(o);
+  }
+  return n;
+}
+function Ot(t, e, r) {
+  if (Object.values(e.functions).includes(t)) return !0;
+  for (const s of Object.values(r))
+    if (typeof s == "object" && s !== null) {
+      for (const o of Object.values(s))
+        if (o === t) {
+          const a = Object.freeze({
+            abs: Math.abs,
+            acos: Math.acos,
+            asin: Math.asin,
+            atan: Math.atan,
+            atan2: Math.atan2,
+            ceil: Math.ceil,
+            clz32: Math.clz32,
+            cos: Math.cos,
+            exp: Math.exp,
+            floor: Math.floor,
+            imul: Math.imul,
+            fround: Math.fround,
+            f16round: Math.f16round,
+            log: Math.log,
+            max: Math.max,
+            min: Math.min,
+            pow: Math.pow,
+            random: Math.random,
+            round: Math.round,
+            sin: Math.sin,
+            sqrt: Math.sqrt,
+            tan: Math.tan,
+            log10: Math.log10,
+            log2: Math.log2,
+            log1p: Math.log1p,
+            expm1: Math.expm1,
+            cosh: Math.cosh,
+            sinh: Math.sinh,
+            tanh: Math.tanh,
+            acosh: Math.acosh,
+            asinh: Math.asinh,
+            atanh: Math.atanh,
+            hypot: Math.hypot,
+            trunc: Math.trunc,
+            sign: Math.sign,
+            cbrt: Math.cbrt
+          });
+          for (var n of Object.getOwnPropertyNames(a))
+            if (a[n] === o) return !0;
+          return Object.values(e.functions).includes(o);
+        }
+    }
+  return !1;
+}
+function Y(t, e, r) {
+  var n = [], s, o, a, u, y, M;
+  if (Ct(t))
+    return V(t, r);
+  for (var E = t.length, N = 0; N < E; N++) {
+    var c = t[N], b = c.type;
+    if (b === X || b === H)
+      n.push(c.value);
+    else if (b === ht)
+      o = n.pop(), s = n.pop(), c.value === "and" ? n.push(s ? !!Y(o, e, r) : !1) : c.value === "or" ? n.push(s ? !0 : !!Y(o, e, r)) : c.value === "=" ? (u = e.binaryOps[c.value], n.push(u(s, Y(o, e, r), r))) : (u = e.binaryOps[c.value], n.push(u(V(s, r), V(o, r))));
+    else if (b === ct)
+      a = n.pop(), o = n.pop(), s = n.pop(), c.value === "?" ? n.push(Y(s ? o : a, e, r)) : (u = e.ternaryOps[c.value], n.push(u(V(s, r), V(o, r), V(a, r))));
+    else if (b === z) {
+      if (/^__proto__|prototype|constructor$/.test(c.value))
+        throw new Error("prototype access detected");
+      if (c.value in e.functions)
+        n.push(e.functions[c.value]);
+      else if (c.value in e.unaryOps && e.parser.isOperatorEnabled(c.value))
+        n.push(e.unaryOps[c.value]);
+      else {
+        var R = r[c.value];
+        if (R !== void 0) {
+          if (typeof R == "function" && !Ot(R, e, r))
+            throw new Error("Variable references an unallowed function: " + c.value);
+          n.push(R);
+        } else
+          throw new Error("undefined variable: " + c.value);
+      }
+    } else if (b === ut)
+      s = n.pop(), u = e.unaryOps[c.value], n.push(u(V(s, r)));
+    else if (b === at) {
+      for (M = c.value, y = []; M-- > 0; )
+        y.unshift(V(n.pop(), r));
+      if (u = n.pop(), !Ot(u, e, r))
+        throw new Error("Is not an allowed function.");
+      if (u.apply && u.call)
+        n.push(u.apply(void 0, y));
+      else
+        throw new Error(u + " is not a function");
+    } else if (b === yt)
+      n.push(function() {
+        for (var D = n.pop(), d = [], g = c.value; g-- > 0; )
+          d.unshift(n.pop());
+        var S = n.pop(), k = function() {
+          for (var wt = Object.assign({}, r), Q = 0, pt = d.length; Q < pt; Q++)
+            wt[d[Q]] = arguments[Q];
+          return Y(D, e, wt);
+        };
+        return e.functions["lambda_" + e.functions.__counter++] = k, r[S] = k, k;
+      }());
+    else if (b === F)
+      n.push(ee(c, e));
+    else if (b === Nt)
+      n.push(c);
+    else if (b === Z) {
+      if (s = n.pop(), /^__proto__|prototype|constructor$/.test(c.value))
+        throw new Error("prototype access detected in MEMBER");
+      if (typeof s == "object" && typeof s[c.value] == "function" && !Ot(s[c.value], e, r))
+        throw new Error("Is not an allowed function in MEMBER.");
+      n.push(s[c.value]);
+    } else if (b === xt)
+      n.pop();
+    else if (b === ot) {
+      for (M = c.value, y = []; M-- > 0; )
+        y.unshift(n.pop());
+      n.push(y);
+    } else
+      throw new Error("invalid Expression");
+  }
+  if (n.length > 1)
+    throw new Error("invalid Expression (parity)");
+  return n[0] === 0 ? 0 : V(n[0], r);
+}
+function ee(t, e, r) {
+  return Ct(t) ? t : {
+    type: Nt,
+    value: function(n) {
+      return Y(t.value, e, n);
+    }
+  };
+}
+function Ct(t) {
+  return t && t.type === Nt;
+}
+function V(t, e) {
+  return Ct(t) ? t.value(e) : t;
+}
+function It(t, e) {
+  for (var r = [], n, s, o, a, u, y, M = 0; M < t.length; M++) {
+    var E = t[M], N = E.type;
+    if (N === X)
+      typeof E.value == "number" && E.value < 0 ? r.push("(" + E.value + ")") : Array.isArray(E.value) ? r.push("[" + E.value.map(Xt).join(", ") + "]") : r.push(Xt(E.value));
+    else if (N === ht)
+      s = r.pop(), n = r.pop(), a = E.value, e ? a === "^" ? r.push("Math.pow(" + n + ", " + s + ")") : a === "and" ? r.push("(!!" + n + " && !!" + s + ")") : a === "or" ? r.push("(!!" + n + " || !!" + s + ")") : a === "||" ? r.push("(function(a,b){ return Array.isArray(a) && Array.isArray(b) ? a.concat(b) : String(a) + String(b); }((" + n + "),(" + s + ")))") : a === "==" ? r.push("(" + n + " === " + s + ")") : a === "!=" ? r.push("(" + n + " !== " + s + ")") : a === "[" ? r.push(n + "[(" + s + ") | 0]") : r.push("(" + n + " " + a + " " + s + ")") : a === "[" ? r.push(n + "[" + s + "]") : r.push("(" + n + " " + a + " " + s + ")");
+    else if (N === ct)
+      if (o = r.pop(), s = r.pop(), n = r.pop(), a = E.value, a === "?")
+        r.push("(" + n + " ? " + s + " : " + o + ")");
+      else
+        throw new Error("invalid Expression");
+    else if (N === z || N === H)
+      r.push(E.value);
+    else if (N === ut)
+      n = r.pop(), a = E.value, a === "-" || a === "+" ? r.push("(" + a + n + ")") : e ? a === "not" ? r.push("(!" + n + ")") : a === "!" ? r.push("fac(" + n + ")") : r.push(a + "(" + n + ")") : a === "!" ? r.push("(" + n + "!)") : r.push("(" + a + " " + n + ")");
+    else if (N === at) {
+      for (y = E.value, u = []; y-- > 0; )
+        u.unshift(r.pop());
+      a = r.pop(), r.push(a + "(" + u.join(", ") + ")");
+    } else if (N === yt) {
+      for (s = r.pop(), y = E.value, u = []; y-- > 0; )
+        u.unshift(r.pop());
+      n = r.pop(), e ? r.push("(" + n + " = function(" + u.join(", ") + ") { return " + s + " })") : r.push("(" + n + "(" + u.join(", ") + ") = " + s + ")");
+    } else if (N === Z)
+      n = r.pop(), r.push(n + "." + E.value);
+    else if (N === ot) {
+      for (y = E.value, u = []; y-- > 0; )
+        u.unshift(r.pop());
+      r.push("[" + u.join(", ") + "]");
+    } else if (N === F)
+      r.push("(" + It(E.value, e) + ")");
+    else if (N !== xt) throw new Error("invalid Expression");
+  }
+  return r.length > 1 && (e ? r = [r.join(",")] : r = [r.join(";")]), String(r[0]);
+}
+function Xt(t) {
+  return typeof t == "string" ? JSON.stringify(t).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029") : t;
+}
+function nt(t, e) {
+  for (var r = 0; r < t.length; r++)
+    if (t[r] === e)
+      return !0;
+  return !1;
+}
+function St(t, e, r) {
+  r = r || {};
+  for (var n = !!r.withMembers, s = null, o = 0; o < t.length; o++) {
+    var a = t[o];
+    a.type === z || a.type === H ? !n && !nt(e, a.value) ? e.push(a.value) : (s !== null && (nt(e, s) || e.push(s)), s = a.value) : a.type === Z && n && s !== null ? s += "." + a.value : a.type === F ? St(a.value, e, r) : s !== null && (nt(e, s) || e.push(s), s = null);
+  }
+  s !== null && !nt(e, s) && e.push(s);
+}
+function U(t, e) {
+  this.tokens = t, this.parser = e, this.unaryOps = e.unaryOps, this.binaryOps = e.binaryOps, this.ternaryOps = e.ternaryOps, this.functions = e.functions;
+}
+U.prototype.simplify = function(t) {
+  return t = t || {}, new U(Pt(this.tokens, this.unaryOps, this.binaryOps, this.ternaryOps, t), this.parser);
+};
+U.prototype.substitute = function(t, e) {
+  return e instanceof U || (e = this.parser.parse(String(e))), new U(Gt(this.tokens, t, e), this.parser);
+};
+U.prototype.evaluate = function(t) {
+  return t = t || {}, Y(this.tokens, this, t);
+};
+U.prototype.toString = function() {
+  return It(this.tokens, !1);
+};
+U.prototype.symbols = function(t) {
+  t = t || {};
+  var e = [];
+  return St(this.tokens, e, t), e;
+};
+U.prototype.variables = function(t) {
+  t = t || {};
+  var e = [];
+  St(this.tokens, e, t);
+  var r = this.functions;
+  return e.filter(function(n) {
+    return !(n in r);
+  });
+};
+U.prototype.toJSFunction = function(t, e) {
+  var r = this, n = new Function(t, "with(this.functions) with (this.ternaryOps) with (this.binaryOps) with (this.unaryOps) { return " + It(this.simplify(e).tokens, !0) + "; }");
+  return function() {
+    return n.apply(r, arguments);
+  };
+};
+var dt = "TEOF", O = "TOP", Et = "TNUMBER", Kt = "TSTRING", W = "TPAREN", it = "TBRACKET", At = "TCOMMA", $t = "TNAME", Rt = "TSEMICOLON";
+function Yt(t, e, r) {
+  this.type = t, this.value = e, this.index = r;
+}
+Yt.prototype.toString = function() {
+  return this.type + ": " + this.value;
+};
+function C(t, e) {
+  this.pos = 0, this.current = null, this.unaryOps = t.unaryOps, this.binaryOps = t.binaryOps, this.ternaryOps = t.ternaryOps, this.consts = t.consts, this.expression = e, this.savedPosition = 0, this.savedCurrent = null, this.options = t.options, this.parser = t;
+}
+C.prototype.newToken = function(t, e, r) {
+  return new Yt(t, e, r ?? this.pos);
+};
+C.prototype.save = function() {
+  this.savedPosition = this.pos, this.savedCurrent = this.current;
+};
+C.prototype.restore = function() {
+  this.pos = this.savedPosition, this.current = this.savedCurrent;
+};
+C.prototype.next = function() {
+  if (this.pos >= this.expression.length)
+    return this.newToken(dt, "EOF");
+  if (this.isWhitespace() || this.isComment())
+    return this.next();
+  if (this.isRadixInteger() || this.isNumber() || this.isOperator() || this.isString() || this.isParen() || this.isBracket() || this.isComma() || this.isSemicolon() || this.isNamedOp() || this.isConst() || this.isName())
+    return this.current;
+  this.parseError('Unknown character "' + this.expression.charAt(this.pos) + '"');
+};
+C.prototype.isString = function() {
+  var t = !1, e = this.pos, r = this.expression.charAt(e);
+  if (r === "'" || r === '"')
+    for (var n = this.expression.indexOf(r, e + 1); n >= 0 && this.pos < this.expression.length; ) {
+      if (this.pos = n + 1, this.expression.charAt(n - 1) !== "\\") {
+        var s = this.expression.substring(e + 1, n);
+        this.current = this.newToken(Kt, this.unescape(s), e), t = !0;
+        break;
+      }
+      n = this.expression.indexOf(r, n + 1);
+    }
+  return t;
+};
+C.prototype.isParen = function() {
+  var t = this.expression.charAt(this.pos);
+  return t === "(" || t === ")" ? (this.current = this.newToken(W, t), this.pos++, !0) : !1;
+};
+C.prototype.isBracket = function() {
+  var t = this.expression.charAt(this.pos);
+  return (t === "[" || t === "]") && this.isOperatorEnabled("[") ? (this.current = this.newToken(it, t), this.pos++, !0) : !1;
+};
+C.prototype.isComma = function() {
+  var t = this.expression.charAt(this.pos);
+  return t === "," ? (this.current = this.newToken(At, ","), this.pos++, !0) : !1;
+};
+C.prototype.isSemicolon = function() {
+  var t = this.expression.charAt(this.pos);
+  return t === ";" ? (this.current = this.newToken(Rt, ";"), this.pos++, !0) : !1;
+};
+C.prototype.isConst = function() {
+  for (var t = this.pos, e = t; e < this.expression.length; e++) {
+    var r = this.expression.charAt(e);
+    if (r.toUpperCase() === r.toLowerCase() && (e === this.pos || r !== "_" && r !== "." && (r < "0" || r > "9")))
+      break;
+  }
+  if (e > t) {
+    var n = this.expression.substring(t, e);
+    if (n in this.consts)
+      return this.current = this.newToken(Et, this.consts[n]), this.pos += n.length, !0;
+  }
+  return !1;
+};
+C.prototype.isNamedOp = function() {
+  for (var t = this.pos, e = t; e < this.expression.length; e++) {
+    var r = this.expression.charAt(e);
+    if (r.toUpperCase() === r.toLowerCase() && (e === this.pos || r !== "_" && (r < "0" || r > "9")))
+      break;
+  }
+  if (e > t) {
+    var n = this.expression.substring(t, e);
+    if (this.isOperatorEnabled(n) && (n in this.binaryOps || n in this.unaryOps || n in this.ternaryOps))
+      return this.current = this.newToken(O, n), this.pos += n.length, !0;
+  }
+  return !1;
+};
+C.prototype.isName = function() {
+  for (var t = this.pos, e = t, r = !1; e < this.expression.length; e++) {
+    var n = this.expression.charAt(e);
+    if (n.toUpperCase() === n.toLowerCase()) {
+      if (e === this.pos && (n === "$" || n === "_")) {
+        n === "_" && (r = !0);
+        continue;
+      } else if (e === this.pos || !r || n !== "_" && (n < "0" || n > "9"))
+        break;
+    } else
+      r = !0;
+  }
+  if (r) {
+    var s = this.expression.substring(t, e);
+    return this.current = this.newToken($t, s), this.pos += s.length, !0;
+  }
+  return !1;
+};
+C.prototype.isWhitespace = function() {
+  for (var t = !1, e = this.expression.charAt(this.pos); (e === " " || e === "	" || e === `
+` || e === "\r") && (t = !0, this.pos++, !(this.pos >= this.expression.length)); )
+    e = this.expression.charAt(this.pos);
+  return t;
+};
+var re = /^[0-9a-f]{4}$/i;
+C.prototype.unescape = function(t) {
+  var e = t.indexOf("\\");
+  if (e < 0)
+    return t;
+  for (var r = t.substring(0, e); e >= 0; ) {
+    var n = t.charAt(++e);
+    switch (n) {
+      case "'":
+        r += "'";
+        break;
+      case '"':
+        r += '"';
+        break;
+      case "\\":
+        r += "\\";
+        break;
+      case "/":
+        r += "/";
+        break;
+      case "b":
+        r += "\b";
+        break;
+      case "f":
+        r += "\f";
+        break;
+      case "n":
+        r += `
+`;
+        break;
+      case "r":
+        r += "\r";
+        break;
+      case "t":
+        r += "	";
+        break;
+      case "u":
+        var s = t.substring(e + 1, e + 5);
+        re.test(s) || this.parseError("Illegal escape sequence: \\u" + s), r += String.fromCharCode(parseInt(s, 16)), e += 4;
+        break;
+      default:
+        throw this.parseError('Illegal escape sequence: "\\' + n + '"');
+    }
+    ++e;
+    var o = t.indexOf("\\", e);
+    r += t.substring(e, o < 0 ? t.length : o), e = o;
+  }
+  return r;
+};
+C.prototype.isComment = function() {
+  var t = this.expression.charAt(this.pos);
+  return t === "/" && this.expression.charAt(this.pos + 1) === "*" ? (this.pos = this.expression.indexOf("*/", this.pos) + 2, this.pos === 1 && (this.pos = this.expression.length), !0) : !1;
+};
+C.prototype.isRadixInteger = function() {
+  var t = this.pos;
+  if (t >= this.expression.length - 2 || this.expression.charAt(t) !== "0")
+    return !1;
+  ++t;
+  var e, r;
+  if (this.expression.charAt(t) === "x")
+    e = 16, r = /^[0-9a-f]$/i, ++t;
+  else if (this.expression.charAt(t) === "b")
+    e = 2, r = /^[01]$/i, ++t;
+  else
+    return !1;
+  for (var n = !1, s = t; t < this.expression.length; ) {
+    var o = this.expression.charAt(t);
+    if (r.test(o))
+      t++, n = !0;
+    else
+      break;
+  }
+  return n && (this.current = this.newToken(Et, parseInt(this.expression.substring(s, t), e)), this.pos = t), n;
+};
+C.prototype.isNumber = function() {
+  for (var t = !1, e = this.pos, r = e, n = e, s = !1, o = !1, a; e < this.expression.length && (a = this.expression.charAt(e), a >= "0" && a <= "9" || !s && a === "."); )
+    a === "." ? s = !0 : o = !0, e++, t = o;
+  if (t && (n = e), a === "e" || a === "E") {
+    e++;
+    for (var u = !0, y = !1; e < this.expression.length; ) {
+      if (a = this.expression.charAt(e), u && (a === "+" || a === "-"))
+        u = !1;
+      else if (a >= "0" && a <= "9")
+        y = !0, u = !1;
+      else
+        break;
+      e++;
+    }
+    y || (e = n);
+  }
+  return t ? (this.current = this.newToken(Et, parseFloat(this.expression.substring(r, e))), this.pos = e) : this.pos = n, t;
+};
+C.prototype.isOperator = function() {
+  var t = this.pos, e = this.expression.charAt(this.pos);
+  if (e === "+" || e === "-" || e === "*" || e === "/" || e === "%" || e === "^" || e === "?" || e === ":" || e === ".")
+    this.current = this.newToken(O, e);
+  else if (e === "∙" || e === "•")
+    this.current = this.newToken(O, "*");
+  else if (e === ">")
+    this.expression.charAt(this.pos + 1) === "=" ? (this.current = this.newToken(O, ">="), this.pos++) : this.current = this.newToken(O, ">");
+  else if (e === "<")
+    this.expression.charAt(this.pos + 1) === "=" ? (this.current = this.newToken(O, "<="), this.pos++) : this.current = this.newToken(O, "<");
+  else if (e === "|")
+    if (this.expression.charAt(this.pos + 1) === "|")
+      this.current = this.newToken(O, "||"), this.pos++;
+    else
+      return !1;
+  else if (e === "=")
+    this.expression.charAt(this.pos + 1) === "=" ? (this.current = this.newToken(O, "=="), this.pos++) : this.current = this.newToken(O, e);
+  else if (e === "!")
+    this.expression.charAt(this.pos + 1) === "=" ? (this.current = this.newToken(O, "!="), this.pos++) : this.current = this.newToken(O, e);
+  else
+    return !1;
+  return this.pos++, this.isOperatorEnabled(this.current.value) ? !0 : (this.pos = t, !1);
+};
+C.prototype.isOperatorEnabled = function(t) {
+  return this.parser.isOperatorEnabled(t);
+};
+C.prototype.getCoordinates = function() {
+  var t = 0, e, r = -1;
+  do
+    t++, e = this.pos - r, r = this.expression.indexOf(`
+`, r + 1);
+  while (r >= 0 && r < this.pos);
+  return {
+    line: t,
+    column: e
+  };
+};
+C.prototype.parseError = function(t) {
+  var e = this.getCoordinates();
+  throw new Error("parse error [" + e.line + ":" + e.column + "]: " + t);
+};
+function P(t, e, r) {
+  this.parser = t, this.tokens = e, this.current = null, this.nextToken = null, this.next(), this.savedCurrent = null, this.savedNextToken = null, this.allowMemberAccess = r.allowMemberAccess !== !1;
+}
+P.prototype.next = function() {
+  return this.current = this.nextToken, this.nextToken = this.tokens.next();
+};
+P.prototype.tokenMatches = function(t, e) {
+  return typeof e > "u" ? !0 : Array.isArray(e) ? nt(e, t.value) : typeof e == "function" ? e(t) : t.value === e;
+};
+P.prototype.save = function() {
+  this.savedCurrent = this.current, this.savedNextToken = this.nextToken, this.tokens.save();
+};
+P.prototype.restore = function() {
+  this.tokens.restore(), this.current = this.savedCurrent, this.nextToken = this.savedNextToken;
+};
+P.prototype.accept = function(t, e) {
+  return this.nextToken.type === t && this.tokenMatches(this.nextToken, e) ? (this.next(), !0) : !1;
+};
+P.prototype.expect = function(t, e) {
+  if (!this.accept(t, e)) {
+    var r = this.tokens.getCoordinates();
+    throw new Error("parse error [" + r.line + ":" + r.column + "]: Expected " + (e || t));
+  }
+};
+P.prototype.parseAtom = function(t) {
+  var e = this.tokens.unaryOps;
+  function r(s) {
+    return s.value in e;
+  }
+  if (this.accept($t) || this.accept(O, r))
+    t.push(new x(z, this.current.value));
+  else if (this.accept(Et))
+    t.push(new x(X, this.current.value));
+  else if (this.accept(Kt))
+    t.push(new x(X, this.current.value));
+  else if (this.accept(W, "("))
+    this.parseExpression(t), this.expect(W, ")");
+  else if (this.accept(it, "["))
+    if (this.accept(it, "]"))
+      t.push(new x(ot, 0));
+    else {
+      var n = this.parseArrayList(t);
+      t.push(new x(ot, n));
+    }
+  else
+    throw new Error("unexpected " + this.nextToken);
+};
+P.prototype.parseExpression = function(t) {
+  var e = [];
+  this.parseUntilEndStatement(t, e) || (this.parseVariableAssignmentExpression(e), !this.parseUntilEndStatement(t, e) && this.pushExpression(t, e));
+};
+P.prototype.pushExpression = function(t, e) {
+  for (var r = 0, n = e.length; r < n; r++)
+    t.push(e[r]);
+};
+P.prototype.parseUntilEndStatement = function(t, e) {
+  return this.accept(Rt) ? (this.nextToken && this.nextToken.type !== dt && !(this.nextToken.type === W && this.nextToken.value === ")") && e.push(new x(xt)), this.nextToken.type !== dt && this.parseExpression(e), t.push(new x(F, e)), !0) : !1;
+};
+P.prototype.parseArrayList = function(t) {
+  for (var e = 0; !this.accept(it, "]"); )
+    for (this.parseExpression(t), ++e; this.accept(At); )
+      this.parseExpression(t), ++e;
+  return e;
+};
+P.prototype.parseVariableAssignmentExpression = function(t) {
+  for (this.parseConditionalExpression(t); this.accept(O, "="); ) {
+    var e = t.pop(), r = [], n = t.length - 1;
+    if (e.type === at) {
+      if (!this.tokens.isOperatorEnabled("()="))
+        throw new Error("function definition is not permitted");
+      for (var s = 0, o = e.value + 1; s < o; s++) {
+        var a = n - s;
+        t[a].type === z && (t[a] = new x(H, t[a].value));
+      }
+      this.parseVariableAssignmentExpression(r), t.push(new x(F, r)), t.push(new x(yt, e.value));
+      continue;
+    }
+    if (e.type !== z && e.type !== Z)
+      throw new Error("expected variable for assignment");
+    this.parseVariableAssignmentExpression(r), t.push(new x(H, e.value)), t.push(new x(F, r)), t.push(G("="));
+  }
+};
+P.prototype.parseConditionalExpression = function(t) {
+  for (this.parseOrExpression(t); this.accept(O, "?"); ) {
+    var e = [], r = [];
+    this.parseConditionalExpression(e), this.expect(O, ":"), this.parseConditionalExpression(r), t.push(new x(F, e)), t.push(new x(F, r)), t.push(Wt("?"));
+  }
+};
+P.prototype.parseOrExpression = function(t) {
+  for (this.parseAndExpression(t); this.accept(O, "or"); ) {
+    var e = [];
+    this.parseAndExpression(e), t.push(new x(F, e)), t.push(G("or"));
+  }
+};
+P.prototype.parseAndExpression = function(t) {
+  for (this.parseComparison(t); this.accept(O, "and"); ) {
+    var e = [];
+    this.parseComparison(e), t.push(new x(F, e)), t.push(G("and"));
+  }
+};
+var ne = ["==", "!=", "<", "<=", ">=", ">", "in"];
+P.prototype.parseComparison = function(t) {
+  for (this.parseAddSub(t); this.accept(O, ne); ) {
+    var e = this.current;
+    this.parseAddSub(t), t.push(G(e.value));
+  }
+};
+var se = ["+", "-", "||"];
+P.prototype.parseAddSub = function(t) {
+  for (this.parseTerm(t); this.accept(O, se); ) {
+    var e = this.current;
+    this.parseTerm(t), t.push(G(e.value));
+  }
+};
+var ae = ["*", "/", "%"];
+P.prototype.parseTerm = function(t) {
+  for (this.parseFactor(t); this.accept(O, ae); ) {
+    var e = this.current;
+    this.parseFactor(t), t.push(G(e.value));
+  }
+};
+P.prototype.parseFactor = function(t) {
+  var e = this.tokens.unaryOps;
+  function r(s) {
+    return s.value in e;
+  }
+  if (this.save(), this.accept(O, r)) {
+    if (this.current.value !== "-" && this.current.value !== "+") {
+      if (this.nextToken.type === W && this.nextToken.value === "(") {
+        this.restore(), this.parseExponential(t);
+        return;
+      } else if (this.nextToken.type === Rt || this.nextToken.type === At || this.nextToken.type === dt || this.nextToken.type === W && this.nextToken.value === ")") {
+        this.restore(), this.parseAtom(t);
+        return;
+      }
+    }
+    var n = this.current;
+    this.parseFactor(t), t.push(Mt(n.value));
+  } else
+    this.parseExponential(t);
+};
+P.prototype.parseExponential = function(t) {
+  for (this.parsePostfixExpression(t); this.accept(O, "^"); )
+    this.parseFactor(t), t.push(G("^"));
+};
+P.prototype.parsePostfixExpression = function(t) {
+  for (this.parseFunctionCall(t); this.accept(O, "!"); )
+    t.push(Mt("!"));
+};
+P.prototype.parseFunctionCall = function(t) {
+  var e = this.tokens.unaryOps;
+  function r(o) {
+    return o.value in e;
+  }
+  if (this.accept(O, r)) {
+    var n = this.current;
+    this.parseAtom(t), t.push(Mt(n.value));
+  } else
+    for (this.parseMemberExpression(t); this.accept(W, "("); )
+      if (this.accept(W, ")"))
+        t.push(new x(at, 0));
+      else {
+        var s = this.parseArgumentList(t);
+        t.push(new x(at, s));
+      }
+};
+P.prototype.parseArgumentList = function(t) {
+  for (var e = 0; !this.accept(W, ")"); )
+    for (this.parseExpression(t), ++e; this.accept(At); )
+      this.parseExpression(t), ++e;
+  return e;
+};
+P.prototype.parseMemberExpression = function(t) {
+  for (this.parseAtom(t); this.accept(O, ".") || this.accept(it, "["); ) {
+    var e = this.current;
+    if (e.value === ".") {
+      if (!this.allowMemberAccess)
+        throw new Error('unexpected ".", member access is not permitted');
+      this.expect($t), t.push(new x(Z, this.current.value));
+    } else if (e.value === "[") {
+      if (!this.tokens.isOperatorEnabled("["))
+        throw new Error('unexpected "[]", arrays are disabled');
+      this.parseExpression(t), this.expect(it, "]"), t.push(G("["));
+    } else
+      throw new Error("unexpected symbol: " + e.value);
+  }
+};
+function oe(t, e) {
+  return Number(t) + Number(e);
+}
+function ie(t, e) {
+  return t - e;
+}
+function ue(t, e) {
+  return t * e;
+}
+function he(t, e) {
+  return t / e;
+}
+function ce(t, e) {
+  return t % e;
+}
+function pe(t, e) {
+  return Array.isArray(t) && Array.isArray(e) ? t.concat(e) : "" + t + e;
+}
+function le(t, e) {
+  return t === e;
+}
+function fe(t, e) {
+  return t !== e;
+}
+function ge(t, e) {
+  return t > e;
+}
+function de(t, e) {
+  return t < e;
+}
+function we(t, e) {
+  return t >= e;
+}
+function ve(t, e) {
+  return t <= e;
+}
+function ye(t, e) {
+  return !!(t && e);
+}
+function xe(t, e) {
+  return !!(t || e);
+}
+function Me(t, e) {
+  return nt(e, t);
+}
+function Ee(t) {
+  return (Math.exp(t) - Math.exp(-t)) / 2;
+}
+function Ae(t) {
+  return (Math.exp(t) + Math.exp(-t)) / 2;
+}
+function me(t) {
+  return t === 1 / 0 ? 1 : t === -1 / 0 ? -1 : (Math.exp(t) - Math.exp(-t)) / (Math.exp(t) + Math.exp(-t));
+}
+function be(t) {
+  return t === -1 / 0 ? t : Math.log(t + Math.sqrt(t * t + 1));
+}
+function Oe(t) {
+  return Math.log(t + Math.sqrt(t * t - 1));
+}
+function ke(t) {
+  return Math.log((1 + t) / (1 - t)) / 2;
+}
+function Ut(t) {
+  return Math.log(t) * Math.LOG10E;
+}
+function Te(t) {
+  return -t;
+}
+function Pe(t) {
+  return !t;
+}
+function Ne(t) {
+  return t < 0 ? Math.ceil(t) : Math.floor(t);
+}
+function Ce(t) {
+  return Math.random() * (t || 1);
+}
+function Dt(t) {
+  return Ft(t + 1);
+}
+function Ie(t) {
+  return isFinite(t) && t === Math.round(t);
+}
+var Se = 4.7421875, kt = [
+  0.9999999999999971,
+  57.15623566586292,
+  -59.59796035547549,
+  14.136097974741746,
+  -0.4919138160976202,
+  3399464998481189e-20,
+  4652362892704858e-20,
+  -9837447530487956e-20,
+  1580887032249125e-19,
+  -21026444172410488e-20,
+  21743961811521265e-20,
+  -1643181065367639e-19,
+  8441822398385275e-20,
+  -26190838401581408e-21,
+  36899182659531625e-22
+];
+function Ft(t) {
+  var e, r;
+  if (Ie(t)) {
+    if (t <= 0)
+      return isFinite(t) ? 1 / 0 : NaN;
+    if (t > 171)
+      return 1 / 0;
+    for (var n = t - 2, s = t - 1; n > 1; )
+      s *= n, n--;
+    return s === 0 && (s = 1), s;
+  }
+  if (t < 0.5)
+    return Math.PI / (Math.sin(Math.PI * t) * Ft(1 - t));
+  if (t >= 171.35)
+    return 1 / 0;
+  if (t > 85) {
+    var o = t * t, a = o * t, u = a * t, y = u * t;
+    return Math.sqrt(2 * Math.PI / t) * Math.pow(t / Math.E, t) * (1 + 1 / (12 * t) + 1 / (288 * o) - 139 / (51840 * a) - 571 / (2488320 * u) + 163879 / (209018880 * y) + 5246819 / (75246796800 * y * t));
+  }
+  --t, r = kt[0];
+  for (var M = 1; M < kt.length; ++M)
+    r += kt[M] / (t + M);
+  return e = t + Se + 0.5, Math.sqrt(2 * Math.PI) * Math.pow(e, t + 0.5) * Math.exp(-e) * r;
+}
+function $e(t) {
+  return Array.isArray(t) ? t.length : String(t).length;
+}
+function qt() {
+  for (var t = 0, e = 0, r = 0; r < arguments.length; r++) {
+    var n = Math.abs(arguments[r]), s;
+    e < n ? (s = e / n, t = t * s * s + 1, e = n) : n > 0 ? (s = n / e, t += s * s) : t += n;
+  }
+  return e === 1 / 0 ? 1 / 0 : e * Math.sqrt(t);
+}
+function Lt(t, e, r) {
+  return t ? e : r;
+}
+function Re(t, e) {
+  return typeof e > "u" || +e == 0 ? Math.round(t) : (t = +t, e = -+e, isNaN(t) || !(typeof e == "number" && e % 1 === 0) ? NaN : (t = t.toString().split("e"), t = Math.round(+(t[0] + "e" + (t[1] ? +t[1] - e : -e))), t = t.toString().split("e"), +(t[0] + "e" + (t[1] ? +t[1] + e : e))));
+}
+function Fe(t, e, r) {
+  return r && (r[t] = e), e;
+}
+function _e(t, e) {
+  return t[e | 0];
+}
+function je(t) {
+  return arguments.length === 1 && Array.isArray(t) ? Math.max.apply(Math, t) : Math.max.apply(Math, arguments);
+}
+function Xe(t) {
+  return arguments.length === 1 && Array.isArray(t) ? Math.min.apply(Math, t) : Math.min.apply(Math, arguments);
+}
+function Ue(t, e) {
+  if (typeof t != "function")
+    throw new Error("First argument to map is not a function");
+  if (!Array.isArray(e))
+    throw new Error("Second argument to map is not an array");
+  return e.map(function(r, n) {
+    return t(r, n);
+  });
+}
+function De(t, e, r) {
+  if (typeof t != "function")
+    throw new Error("First argument to fold is not a function");
+  if (!Array.isArray(r))
+    throw new Error("Second argument to fold is not an array");
+  return r.reduce(function(n, s, o) {
+    return t(n, s, o);
+  }, e);
+}
+function qe(t, e) {
+  if (typeof t != "function")
+    throw new Error("First argument to filter is not a function");
+  if (!Array.isArray(e))
+    throw new Error("Second argument to filter is not an array");
+  return e.filter(function(r, n) {
+    return t(r, n);
+  });
+}
+function Le(t, e) {
+  if (!(Array.isArray(e) || typeof e == "string"))
+    throw new Error("Second argument to indexOf is not a string or array");
+  return e.indexOf(t);
+}
+function Be(t, e) {
+  if (!Array.isArray(e))
+    throw new Error("Second argument to join is not an array");
+  return e.join(t);
+}
+function Ve(t) {
+  return (t > 0) - (t < 0) || +t;
+}
+var Bt = 1 / 3;
+function ze(t) {
+  return t < 0 ? -Math.pow(-t, Bt) : Math.pow(t, Bt);
+}
+function We(t) {
+  return Math.exp(t) - 1;
+}
+function Ge(t) {
+  return Math.log(1 + t);
+}
+function Ke(t) {
+  return Math.log(t) / Math.LN2;
+}
+function Ye(t) {
+  if (!Array.isArray(t))
+    throw new Error("Sum argument is not an array");
+  return t.reduce(function(e, r) {
+    return e + Number(r);
+  }, 0);
+}
+function J(t) {
+  this.options = t || {}, this.unaryOps = {
+    sin: Math.sin,
+    cos: Math.cos,
+    tan: Math.tan,
+    asin: Math.asin,
+    acos: Math.acos,
+    atan: Math.atan,
+    sinh: Math.sinh || Ee,
+    cosh: Math.cosh || Ae,
+    tanh: Math.tanh || me,
+    asinh: Math.asinh || be,
+    acosh: Math.acosh || Oe,
+    atanh: Math.atanh || ke,
+    sqrt: Math.sqrt,
+    cbrt: Math.cbrt || ze,
+    log: Math.log,
+    log2: Math.log2 || Ke,
+    ln: Math.log,
+    lg: Math.log10 || Ut,
+    log10: Math.log10 || Ut,
+    expm1: Math.expm1 || We,
+    log1p: Math.log1p || Ge,
+    abs: Math.abs,
+    ceil: Math.ceil,
+    floor: Math.floor,
+    round: Math.round,
+    trunc: Math.trunc || Ne,
+    "-": Te,
+    "+": Number,
+    exp: Math.exp,
+    not: Pe,
+    length: $e,
+    "!": Dt,
+    sign: Math.sign || Ve
+  }, this.binaryOps = {
+    "+": oe,
+    "-": ie,
+    "*": ue,
+    "/": he,
+    "%": ce,
+    "^": Math.pow,
+    "||": pe,
+    "==": le,
+    "!=": fe,
+    ">": ge,
+    "<": de,
+    ">=": we,
+    "<=": ve,
+    and: ye,
+    or: xe,
+    in: Me,
+    "=": Fe,
+    "[": _e
+  }, this.ternaryOps = {
+    "?": Lt
+  }, this.functions = {
+    random: Ce,
+    fac: Dt,
+    min: Xe,
+    max: je,
+    hypot: Math.hypot || qt,
+    pyt: Math.hypot || qt,
+    // backward compat
+    pow: Math.pow,
+    atan2: Math.atan2,
+    if: Lt,
+    gamma: Ft,
+    roundTo: Re,
+    map: Ue,
+    fold: De,
+    filter: qe,
+    indexOf: Le,
+    join: Be,
+    sum: Ye
+  }, this.consts = {
+    E: Math.E,
+    PI: Math.PI,
+    true: !0,
+    false: !1
+  };
+}
+J.prototype.parse = function(t) {
+  var e = [], r = new P(
+    this,
+    new C(this, t),
+    { allowMemberAccess: this.options.allowMemberAccess }
+  );
+  return r.parseExpression(e), r.expect(dt, "EOF"), new U(e, this);
+};
+J.prototype.evaluate = function(t, e) {
+  return this.parse(t).evaluate(e);
+};
+var Ht = new J();
+J.parse = function(t) {
+  return Ht.parse(t);
+};
+J.evaluate = function(t, e) {
+  return Ht.parse(t).evaluate(e);
+};
+var Vt = {
+  "+": "add",
+  "-": "subtract",
+  "*": "multiply",
+  "/": "divide",
+  "%": "remainder",
+  "^": "power",
+  "!": "factorial",
+  "<": "comparison",
+  ">": "comparison",
+  "<=": "comparison",
+  ">=": "comparison",
+  "==": "comparison",
+  "!=": "comparison",
+  "||": "concatenate",
+  and: "logical",
+  or: "logical",
+  not: "logical",
+  "?": "conditional",
+  ":": "conditional",
+  "=": "assignment",
+  "[": "array",
+  "()=": "fndef"
+};
+function He(t) {
+  return Object.hasOwn(Vt, t) ? Vt[t] : t;
+}
+J.prototype.isOperatorEnabled = function(t) {
+  var e = He(t), r = this.options.operators || {};
+  return !(e in r) || !!r[e];
+};
+class Ze extends J {
+  constructor(...e) {
+    super(...e);
+    const r = this;
+    r.unaryOps = {
+      "-": r.unaryOps["-"],
+      "+": r.unaryOps["+"],
+      "!": r.unaryOps.not,
+      not: r.unaryOps.not
+    }, r.functions = {
+      sin: Math.sin,
+      cos: Math.cos,
+      tan: Math.tan,
+      asin: Math.asin,
+      acos: Math.acos,
+      atan: Math.atan,
+      log: Math.log,
+      atan2: Math.atan2,
+      pow: Math.pow,
+      radians: (n) => n * (Math.PI / 180),
+      degrees: (n) => n * (180 / Math.PI),
+      __read_property__: (n, ...s) => {
+        let o = n;
+        for (let a = 0, u = s.length; a < u; a++)
+          o = o[s[a]];
+        return o;
+      }
+    }, r.binaryOps = {
+      ...r.binaryOps,
+      "+": (n, s) => (gt(n) && (n = Number(n)), gt(s) && (s = Number(s)), n + s),
+      in: (n, s) => Array.isArray(s) || typeof s == "string" ? s.includes(n) : n in s,
+      "||": (n, s) => !!(n || s)
+      // binary AND is not supported by expr-eval. See expr-eval issue #253.
+      // '&&': (a, b) => Boolean(a || b),
+    }, r.consts = {
+      ...r.consts,
+      pi: Math.PI,
+      tau: 2 * Math.PI,
+      e: Math.E
+    };
+  }
+}
+class Je {
+  constructor() {
+    this.inOrder = !0, this.requirePrefix = !0, this.localProperties = !0, this.rospackCommands = {}, this.arguments = {}, this.expressionParser = new Ze(), this.workingPath = "";
+  }
+  async getFileContents(e) {
+    throw new Error("XacroParser: getFileContents() not implemented.");
+  }
+  async parse(e) {
+    function r(i, h, w = !1) {
+      function l(f, m) {
+        if (typeof f != "string")
+          return f;
+        const $ = f.split(/(\$?\$\([^)]+\))|(\$?\${[^}]+})/g).filter((v) => !!v).map((v) => {
+          if (!/^\$[{(].+/.test(v) || /^\$\$/.test(v))
+            return v;
+          const B = /^\$\(/.test(v);
+          let _ = v.substring(2, v.length - 1);
+          if (_ = l(_, m), /\[.+\]$/.test(_) && (_ = _.replace(/([^[\s]+)(\[[^[]+\])+/g, (tt, ...L) => {
+            const I = tt.split(/[[\]]+/g);
+            return I.pop(), `__read_property__( ${I.join(",")} )`;
+          })), B) {
+            const L = l(_, m).split(/\s+/g), I = L.shift();
+            try {
+              return wt(I, ...L);
+            } catch (et) {
+              throw new Error(`XacroParser: Cannot run rospack command "${_}".
+` + et.message);
+            }
+          } else {
+            if (A.includes(_))
+              throw new Error(
+                `XacroParser: Cannot evaluate infinitely recursive expression: ${A.join(" > ")} > ${_}`
+              );
+            A.push(_);
+            const tt = /([()/*+!\-%|&=])+/g, L = Jt(_).map((I) => {
+              if (tt.lastIndex = 0, Zt(I) || gt(I) || jt(I)) return I;
+              if (I in m) {
+                const et = l(m[I], m);
+                return !gt(et) && typeof et != "object" ? `"${et.toString().replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : et;
+              } else
+                return I;
+            }).map((I) => (tt.lastIndex = 0, /^[^0-9.]/.test(I) && !tt.test(I) ? ` ${I} ` : I)).join("");
+            if (A.pop(), jt(L))
+              return L.substring(1, L.length - 1);
+            if (gt(L))
+              return L;
+            {
+              const I = Qt(L);
+              return Q.evaluate(I, m);
+            }
+          }
+        }), q = $.filter((v) => (typeof v == "string" && (v = v.trim()), v !== "" && v !== null && v !== void 0));
+        return q.length === 1 ? q[0] : $.join("");
+      }
+      const A = [], p = Tt(k, h);
+      try {
+        let f = l(i, p);
+        return w && typeof f == "string" && (f = f.replace(/\${2}([({])/g, (m, T) => `$${T}`)), f;
+      } catch (f) {
+        throw new Error(`XacroParser: Failed to process expression "${i}". 
+` + f.message);
+      }
+    }
+    async function n(i, h, w, l) {
+      const A = i.tagName.replace(/^xacro:/, ""), p = w[A];
+      if (!p)
+        throw new Error(`XacroParser: Cannot find macro "${A}"`);
+      const f = h, m = w;
+      h = te(h), w = Tt(w);
+      let T = [];
+      for (const v of i.children)
+        await a(v, f, m, T);
+      T = T.filter((v) => v.nodeType === v.ELEMENT_NODE);
+      let $ = 0;
+      for (const v in p.params) {
+        const B = p.params[v];
+        i.hasAttribute(v) ? h[v] = r(i.getAttribute(v), f) : B.type === "BLOCK" ? (h[v] = [T[$]], $++) : B.type === "MULTI_BLOCK" ? h[v] = [...T.filter((_) => _.tagName === v)[0].childNodes] : h[v] = r(p.params[v].def, f);
+      }
+      const q = [...p.node.childNodes];
+      for (const v of q) {
+        const B = [];
+        await a(v, h, w, B), l.push(...B);
+      }
+    }
+    function s(i) {
+      const h = {};
+      if (/^\*\*/.test(i) ? h.type = "MULTI_BLOCK" : /^\*/.test(i) ? h.type = "BLOCK" : h.type = "PARAM", i = i.replace(/^\*{1,2}/g, ""), /:?=/.test(i)) {
+        const [w, l] = i.split(/:?=/);
+        if (/^\^/.test(l) || /\|/.test(l))
+          throw new Error(`XacroParser: ROS Jade pass-through notation not supported in macro defaults: ${l}`);
+        h.name = w, l.startsWith("'") && l.endsWith("'") ? h.def = l.substring(1, l.length - 1) : h.def = l;
+      } else
+        h.name = i, h.def = null;
+      return h;
+    }
+    function o(i) {
+      const h = i.getAttribute("name").replace(/^xacro:/, ""), w = i.getAttribute("params"), l = {};
+      return w && w.trim().match(/[^\s']+('[^']*')?/g).map((p) => s(p)).forEach((p) => {
+        l[p.name] = p;
+      }), {
+        name: h,
+        node: ft(i, !1),
+        params: l
+      };
+    }
+    async function a(i, h, w, l = []) {
+      if (i.nodeType === i.TEXT_NODE) {
+        const p = i.cloneNode();
+        p.textContent = r(p.textContent, h, !0), l.push(p);
+        return;
+      } else if (i.nodeType !== i.ELEMENT_NODE) {
+        l.push(i.cloneNode());
+        return;
+      }
+      let A = i.tagName.toLowerCase();
+      if (!R)
+        switch (A) {
+          case "arg":
+          case "property":
+          case "macro":
+          case "insert_block":
+          case "if":
+          case "unless":
+          case "include":
+          case "element":
+          case "attribute":
+            A = `xacro:${A}`;
+            break;
+          default:
+            A in w && (A = `xacro:${A}`);
+            break;
+        }
+      switch (A) {
+        case "xacro:property": {
+          rt(l);
+          const p = i.getAttribute("name");
+          let f;
+          if (i.hasAttribute("value"))
+            f = i.getAttribute("value");
+          else if (i.hasAttribute("default"))
+            f = i.getAttribute("default");
+          else {
+            const T = [...i.childNodes];
+            f = [];
+            for (const $ of T)
+              f.push(ft($, !1));
+          }
+          let m = "global";
+          pt && (m = i.getAttribute("scope") || "local"), m !== "local" && (f = r(f, h)), m === "global" ? k[p] = f : m === "parent" ? h[st][p] = f : h[p] = f;
+          break;
+        }
+        case "xacro:macro": {
+          rt(l);
+          const p = o(i);
+          w[p.name] = p;
+          break;
+        }
+        case "xacro:insert_block": {
+          rt(l);
+          const p = i.getAttribute("name"), f = h[p];
+          for (const m of f)
+            await a(m, h, w, l);
+          return;
+        }
+        case "xacro:if":
+        case "xacro:unless": {
+          rt(l);
+          const p = r(i.getAttribute("value"), h, !0);
+          let f = null;
+          if (isNaN(parseFloat(p)) ? p === "true" || p === "false" ? f = p === "true" : f = p : f = !!parseFloat(p), A === "xacro:unless" && (f = !f), f) {
+            const m = [...i.childNodes];
+            for (const T of m)
+              await a(T, h, w, l);
+          }
+          return;
+        }
+        case "xacro:include": {
+          if (rt(l), i.hasAttribute("ns"))
+            throw new Error("XacroParser: xacro:include name spaces not supported.");
+          const p = r(i.getAttribute("filename"), h, !0), m = /^[/\\]/.test(p) || /^[a-zA-Z]+:[/\\]/.test(p) ? p : vt + p, T = vt;
+          vt = _t(m);
+          const q = [...(await M(m)).children[0].childNodes];
+          for (const v of q)
+            await a(v, h, w, l);
+          vt = T;
+          return;
+        }
+        case "xacro:arg": {
+          const p = i.getAttribute("name");
+          S[p] = r(i.getAttribute("default"), h, !0);
+          return;
+        }
+        case "xacro:attribute":
+        case "xacro:element":
+          throw new Error(`XacroParser: ${A} tags not supported.`);
+        default: {
+          if (/^xacro:/.test(A) || A in w)
+            return rt(l), n(i, h, w, l);
+          {
+            const p = i.cloneNode();
+            for (let T = 0, $ = p.attributes.length; T < $; T++) {
+              const q = p.attributes[T], v = r(q.value, h, !0);
+              p.setAttribute(q.name, v);
+            }
+            const f = [...i.childNodes], m = [];
+            for (let T = 0, $ = f.length; T < $; T++)
+              await a(f[T], h, w, m);
+            m.forEach((T) => p.appendChild(T)), l.push(p);
+          }
+        }
+      }
+    }
+    async function u(i, h, w) {
+      const l = K(i, "xacro:property");
+      R || l.push(...K(i, "property"));
+      for (const p of l)
+        await a(p, h, w);
+      const A = K(i, "xacro:macro");
+      R || A.push(...K(i, "macro"));
+      for (const p of A)
+        await a(p, h, w);
+    }
+    async function y(i, h, w) {
+      const l = i.cloneNode();
+      for (let A = 0, p = i.children.length; A < p; A++) {
+        const f = [];
+        await a(i.children[A], h, w, f);
+        const m = f[0];
+        m.removeAttribute("xmlns:xacro"), l.appendChild(m);
+      }
+      return l;
+    }
+    async function M(i) {
+      try {
+        const h = await N.getFileContents(i);
+        return new DOMParser().parseFromString(h, "text/xml");
+      } catch {
+        throw new Error(`XacroParser: Could not load included file: ${i}`);
+      }
+    }
+    async function E(i, h, w = []) {
+      const l = K(i, "xacro:include");
+      R || l.push(...K(i, "include"));
+      const A = l.map((p) => {
+        if (p.hasAttribute("ns"))
+          throw new Error("XacroParser: xacro:include name spaces not supported.");
+        const f = p.getAttribute("filename"), m = p.getAttribute("ns") || null, $ = /^[/\\]/.test(f) || /^[a-zA-Z]+:[/\\]/.test(f) ? f : h + f;
+        return M($).then((v) => {
+          w.push({ filename: f, namespace: m, content: v });
+          const B = _t($);
+          return E(v, B, w);
+        });
+      });
+      return await Promise.all(A), w;
+    }
+    const N = this, c = this.inOrder, b = this.workingPath + (this.workingPath && !/[\\/]$/.test(this.workingPath) ? "/" : ""), R = this.requirePrefix, D = this.rospackCommands, d = {}, g = {}, S = {}, k = { True: 1, False: 0 };
+    k[st] = k;
+    const wt = (i, ...h) => {
+      let w;
+      if (D instanceof Function && (w = D(i, ...h)), w == null && D != null && typeof D[i] == "function" && (w = D[i](...h)), w == null && i === "arg") {
+        const l = h[0];
+        if (l === void 0)
+          throw new Error("XacroParser: $(arg) must specify a variable name");
+        if (w = this.arguments[l], w == null && (w = S[l]), w == null)
+          throw new Error(`XacroParser: Undefined substitution argument ${l}`);
+      }
+      return w;
+    }, Q = this.expressionParser;
+    let pt = this.localProperties, vt = b, lt = new DOMParser().parseFromString(e, "text/xml");
+    pt && !c && (console.warn('XacroParser: Implicitly setting "localProperties" option to false because "inOrder" is false.'), pt = !1);
+    let mt = null;
+    return c ? mt = Promise.resolve() : mt = async function() {
+      return await u(lt, k, d), lt = ft(lt, !0), E(lt, b).then((i) => {
+        i.forEach((h) => {
+          u(h.content, k, d), h.content = ft(h.content, !0), g[h.filename] = h.content;
+        });
+      });
+    }(), await mt, y(lt, k, d);
+  }
+}
+const zt = "http://wiki.ros.org/xacro", j = (t) => Object.assign(new Error(t), { code: "E_XACRO_EXPAND" });
+async function er(t, e, r, n, s) {
+  var R, D;
+  s.throwIfAborted();
+  const o = new Map(Object.entries((n == null ? void 0 : n.packages) ?? {})), a = /* @__PURE__ */ new Map();
+  for (const d of r.paths().filter((g) => /(^|\/)package\.xml$/.test(g))) {
+    const S = (D = (R = new DOMParser().parseFromString(await r.text(d), "text/xml").querySelector("package > name")) == null ? void 0 : R.textContent) == null ? void 0 : D.trim();
+    S && a.set(S, [...a.get(S) ?? [], d.slice(0, -11)]);
+  }
+  for (const [d, g] of a)
+    if (!o.has(d)) {
+      if (g.length !== 1) throw j(`Ambiguous ROS package: ${d}. Set xacro.packages explicitly.`);
+      o.set(d, g[0]);
+    }
+  const u = (d) => {
+    if (!o.has(d)) throw j(`Unknown ROS package: ${d}. Upload package.xml or set xacro.packages.`);
+    return "/" + bt(o.get(d));
+  }, y = (d, g) => {
+    if (d.length > 4 * 1024 * 1024) throw j(`Xacro input exceeds 4 MiB: ${g}`);
+    const S = new DOMParser().parseFromString(d, "text/xml");
+    if (S.querySelector("parsererror") || S.doctype) throw j(`Invalid XML or unsupported DOCTYPE: ${g}`);
+    for (const k of Array.from(S.getElementsByTagName("*"))) {
+      if (k.namespaceURI === zt && k.prefix !== "xacro") throw j(`Use the xacro: namespace prefix: ${g}`);
+      if (k.tagName === "xacro:call" || k.tagName === "xacro:include" && k.hasAttribute("ns") || k.tagName === "xacro:macro" && /:=\^/.test(k.getAttribute("params") ?? ""))
+        throw j(`Unsupported Xacro feature ${k.tagName}: ${g}`);
+    }
+  };
+  y(t, e);
+  const M = new Je(), E = /* @__PURE__ */ Object.create(null), N = new DOMParser().parseFromString(t, "text/xml");
+  for (const d of Array.from(N.documentElement.children))
+    if (d.tagName === "xacro:arg" && d.hasAttribute("name") && d.hasAttribute("default")) {
+      const g = d.getAttribute("name");
+      g in E || (E[g] = d.getAttribute("default"));
+    }
+  M.arguments = Object.assign(/* @__PURE__ */ Object.create(null), E, n == null ? void 0 : n.arguments), M.workingPath = "/" + e.replaceAll("\\", "/").split("/").slice(0, -1).join("/");
+  let c = 0, b;
+  M.getFileContents = async (d) => {
+    try {
+      if (s.throwIfAborted(), ++c > 128) throw j("Xacro include limit exceeded (128); check for include cycles.");
+      const g = bt(d);
+      if (g === ".." || g.startsWith("../") || /^[a-z]+:/i.test(g)) throw j(`Unsupported include path: ${d}`);
+      const S = await r.text(g);
+      return s.throwIfAborted(), y(S, g), S;
+    } catch (g) {
+      throw b = g, g;
+    }
+  }, M.rospackCommands = (d, ...g) => {
+    if (d !== "arg") {
+      if (d === "find" && g.length === 1) return u(g[0]);
+      throw j(`Unsupported Xacro substitution: $(${d} ${g.join(" ")})`);
+    }
+  };
+  try {
+    const d = await M.parse(t);
+    if (s.throwIfAborted(), d.documentElement.tagName !== "robot") throw j("Expanded Xacro must have a robot root.");
+    for (const g of Array.from(d.getElementsByTagName("*"))) {
+      if (g.prefix === "xacro" || g.namespaceURI === zt) throw j(`Unexpanded Xacro element: ${g.tagName}`);
+      for (const S of Array.from(g.attributes))
+        if (/\$\{|\$\(/.test(S.value)) throw j(`Unexpanded Xacro expression: ${S.value}`);
+      if (g.tagName === "mesh" || g.tagName === "texture") {
+        const S = g.getAttribute("filename") ?? "", k = /^package:\/\/([^/]+)\/(.+)$/.exec(S);
+        k && o.has(k[1]) && g.setAttribute("filename", bt(`${u(k[1])}/${k[2]}`));
+      }
+    }
+    return d.documentElement.outerHTML;
+  } catch (d) {
+    s.throwIfAborted();
+    const g = b ?? d;
+    throw Object.assign(j(`Xacro expansion failed (${e}): ${g instanceof Error ? g.message : String(g)}`), { cause: g });
+  }
+}
+export {
+  er as expandXacro
+};