web-mojo 2.1.1106 → 2.1.1108

package/dist/chunks/{Rest-DpbPbmra.js → Rest-C3KvOEeY.js}

@@ -1,460 +1,3 @@
-const objectToString = Object.prototype.toString;
-const isArray = Array.isArray || function(obj) {
-  return objectToString.call(obj) === "[object Array]";
-};
-const isFunction = function(obj) {
-  return typeof obj === "function";
-};
-const isObject = function(obj) {
-  return obj != null && typeof obj === "object";
-};
-const escapeHtml = function(string) {
-  const entityMap = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;",
-    "/": "&#x2F;",
-    "`": "&#x60;",
-    "=": "&#x3D;"
-  };
-  return String(string).replace(/[&<>"'`=\/]/g, function(s) {
-    return entityMap[s];
-  });
-};
-class Scanner {
-  constructor(string) {
-    this.string = string;
-    this.tail = string;
-    this.pos = 0;
-  }
-  eos() {
-    return this.tail === "";
-  }
-  scan(re) {
-    const match = this.tail.match(re);
-    if (!match || match.index !== 0) {
-      return "";
-    }
-    const string = match[0];
-    this.tail = this.tail.substring(string.length);
-    this.pos += string.length;
-    return string;
-  }
-  scanUntil(re) {
-    const index = this.tail.search(re);
-    let match;
-    switch (index) {
-      case -1:
-        match = this.tail;
-        this.tail = "";
-        break;
-      case 0:
-        match = "";
-        break;
-      default:
-        match = this.tail.substring(0, index);
-        this.tail = this.tail.substring(index);
-    }
-    this.pos += match.length;
-    return match;
-  }
-}
-class Context {
-  constructor(view, parentContext) {
-    this.view = view;
-    this.cache = { ".": this.view };
-    this.parent = parentContext;
-    if (!this.view?._cacheId) {
-      if (this.view && typeof this.view === "object") {
-        this.view._cacheId = Math.random().toString(36).substring(2);
-      }
-    }
-  }
-  push(view) {
-    return new Context(view, this);
-  }
-  lookup(name) {
-    if (this.renderCache && this.view?._cacheId) {
-      const cacheKey = `${this.view._cacheId}:${name}`;
-      if (this.renderCache.has(cacheKey)) {
-        return this.renderCache.get(cacheKey);
-      }
-    }
-    if (name === ".") {
-      return this.view;
-    }
-    if (name && name.startsWith(".")) {
-      let actualName = name.substring(1);
-      let shouldIterate = false;
-      if (actualName.endsWith("|iter")) {
-        actualName = actualName.substring(0, actualName.length - 5);
-        shouldIterate = true;
-      }
-      if (this.view && typeof this.view === "object") {
-        let value2;
-        if (typeof this.view.getContextValue === "function") {
-          try {
-            value2 = this.view.getContextValue(actualName);
-            if (value2 !== void 0) {
-              if (isFunction(value2)) {
-                value2 = value2.call(this.view);
-              }
-            }
-          } catch (e) {
-            value2 = void 0;
-          }
-        }
-        if (value2 === void 0 && actualName in this.view) {
-          value2 = this.view[actualName];
-          if (isFunction(value2)) {
-            value2 = value2.call(this.view);
-          }
-        }
-        if (isArray(value2)) {
-          if (shouldIterate) {
-            return value2;
-          } else {
-            return value2.length > 0;
-          }
-        }
-        if (isObject(value2)) {
-          if (shouldIterate) {
-            return Object.entries(value2).map(([key, val]) => ({
-              key,
-              value: val
-            }));
-          } else {
-            return Object.keys(value2).length > 0;
-          }
-        }
-        return value2;
-      }
-      return void 0;
-    }
-    const cache = this.cache;
-    let value;
-    if (cache.hasOwnProperty(name)) {
-      value = cache[name];
-    } else {
-      let context = this;
-      let intermediateValue;
-      let names;
-      let index;
-      let lookupHit = false;
-      while (context) {
-        if (context.view && typeof context.view.getContextValue === "function") {
-          try {
-            intermediateValue = context.view.getContextValue(name);
-            if (intermediateValue !== void 0) {
-              lookupHit = true;
-            }
-          } catch (e) {
-            lookupHit = false;
-          }
-        }
-        if (!lookupHit) {
-          if (name.indexOf(".") > 0) {
-            intermediateValue = context.view;
-            names = name.split(".");
-            index = 0;
-            while (intermediateValue != null && index < names.length) {
-              if (intermediateValue && typeof intermediateValue.getContextValue === "function" && index < names.length) {
-                try {
-                  const remainingPath = names.slice(index).join(".");
-                  intermediateValue = intermediateValue.getContextValue(remainingPath);
-                  index = names.length;
-                  if (intermediateValue !== void 0) {
-                    lookupHit = true;
-                  }
-                } catch (e) {
-                  if (index === names.length - 1) {
-                    lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
-                  }
-                  intermediateValue = intermediateValue[names[index++]];
-                }
-              } else {
-                if (index === names.length - 1) {
-                  lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
-                }
-                intermediateValue = intermediateValue[names[index++]];
-              }
-            }
-          } else {
-            intermediateValue = context.view[name];
-            lookupHit = hasProperty(context.view, name);
-          }
-        }
-        if (lookupHit) {
-          value = intermediateValue;
-          break;
-        }
-        context = context.parent;
-      }
-      cache[name] = value;
-    }
-    if (isFunction(value)) value = value.call(this.view);
-    if (this.renderCache && this.view?._cacheId) {
-      const cacheKey = `${this.view._cacheId}:${name}`;
-      this.renderCache.set(cacheKey, value);
-    }
-    return value;
-  }
-}
-function hasProperty(obj, propName) {
-  return obj != null && typeof obj === "object" && propName in obj;
-}
-function primitiveHasOwnProperty(primitive, propName) {
-  return primitive != null && typeof primitive !== "object" && primitive.hasOwnProperty && primitive.hasOwnProperty(propName);
-}
-class Writer {
-  constructor() {
-    this.templateCache = /* @__PURE__ */ new Map();
-  }
-  clearCache() {
-    this.templateCache.clear();
-  }
-  parse(template, tags) {
-    tags = tags || ["{{", "}}"];
-    const cacheKey = template + ":" + tags.join(":");
-    let tokens = this.templateCache.get(cacheKey);
-    if (tokens == null) {
-      tokens = this.parseTemplate(template, tags);
-      this.templateCache.set(cacheKey, tokens);
-    }
-    return tokens;
-  }
-  parseTemplate(template, tags) {
-    if (!template) return [];
-    const openingTag = tags[0];
-    const closingTag = tags[1];
-    const scanner = new Scanner(template);
-    const tokens = [];
-    let start, type, value, chr, token;
-    const openingTagRe = new RegExp(escapeRegExp(openingTag) + "\\s*");
-    const closingTagRe = new RegExp("\\s*" + escapeRegExp(closingTag));
-    const closingCurlyRe = new RegExp("\\s*" + escapeRegExp("}" + closingTag));
-    while (!scanner.eos()) {
-      start = scanner.pos;
-      value = scanner.scanUntil(openingTagRe);
-      if (value) {
-        for (let i = 0; i < value.length; ++i) {
-          chr = value.charAt(i);
-          if (chr === "\n") {
-            tokens.push(["text", chr]);
-          } else {
-            tokens.push(["text", chr]);
-          }
-        }
-      }
-      if (!scanner.scan(openingTagRe)) break;
-      type = scanner.scan(/[#^\/>{&=!]/);
-      if (!type) type = "name";
-      scanner.scan(/\s*/);
-      if (type === "=") {
-        value = scanner.scanUntil(/\s*=/);
-        scanner.scan(/\s*=/);
-        scanner.scanUntil(closingTagRe);
-      } else if (type === "{") {
-        value = scanner.scanUntil(closingCurlyRe);
-        scanner.scan(closingCurlyRe);
-        type = "&";
-      } else {
-        value = scanner.scanUntil(closingTagRe);
-      }
-      scanner.scan(closingTagRe);
-      if (type === "#" || type === "^") {
-        token = [type, value, start, scanner.pos];
-        tokens.push(token);
-      } else if (type === "/") {
-        let openSection;
-        for (let i = tokens.length - 1; i >= 0; --i) {
-          if (tokens[i][0] === "#" || tokens[i][0] === "^") {
-            if (tokens[i][1] === value) {
-              openSection = tokens[i];
-              break;
-            }
-          }
-        }
-        if (openSection) {
-          if (openSection.length === 4) {
-            openSection.push(scanner.pos);
-          }
-        }
-        tokens.push([type, value, start, scanner.pos]);
-      } else {
-        tokens.push([type, value, start, scanner.pos]);
-      }
-    }
-    return this.nestSections(this.squashTokens(tokens));
-  }
-  squashTokens(tokens) {
-    const squashedTokens = [];
-    let token, lastToken;
-    for (let i = 0; i < tokens.length; ++i) {
-      token = tokens[i];
-      if (token) {
-        if (token[0] === "text" && lastToken && lastToken[0] === "text") {
-          lastToken[1] += token[1];
-          lastToken[3] = token[3];
-        } else {
-          squashedTokens.push(token);
-          lastToken = token;
-        }
-      }
-    }
-    return squashedTokens;
-  }
-  nestSections(tokens) {
-    const nestedTokens = [];
-    let collector = nestedTokens;
-    const sections = [];
-    for (let i = 0; i < tokens.length; ++i) {
-      const token = tokens[i];
-      switch (token[0]) {
-        case "#":
-        case "^":
-          const sectionToken = [
-            token[0],
-            // type ('#' or '^')
-            token[1],
-            // section name
-            token[2],
-            // start position
-            token[3],
-            // end position after opening tag
-            [],
-            // children array
-            token[4] || null
-            // closing position (if set during parsing)
-          ];
-          collector.push(sectionToken);
-          sections.push(sectionToken);
-          collector = sectionToken[4];
-          break;
-        case "/":
-          const section = sections.pop();
-          if (section) {
-            section[5] = token[2];
-            collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
-          }
-          break;
-        default:
-          collector.push(token);
-      }
-    }
-    return nestedTokens;
-  }
-  render(template, view, partials, config) {
-    const tags = this.getConfigTags(config) || ["{{", "}}"];
-    const tokens = this.parse(template, tags);
-    const renderCache = /* @__PURE__ */ new Map();
-    return this.renderTokens(tokens, new Context(view), partials, template, config, renderCache);
-  }
-  renderTokens(tokens, context, partials, originalTemplate, config, renderCache) {
-    if (renderCache && !context.renderCache) {
-      context.renderCache = renderCache;
-    }
-    let buffer = "";
-    for (let i = 0; i < tokens.length; ++i) {
-      const token = tokens[i];
-      let value;
-      switch (token[0]) {
-        case "#":
-          value = context.lookup(token[1]);
-          if (!value) continue;
-          const childTokens = token[4];
-          if (!childTokens || !isArray(childTokens)) {
-            console.warn(`MUSTACHE WARNING - Section ${token[1]} has no child tokens:`, token);
-            continue;
-          }
-          if (isArray(value)) {
-            for (let j = 0; j < value.length; ++j) {
-              const itemContext = context.push(value[j]);
-              if (context.renderCache) {
-                itemContext.renderCache = context.renderCache;
-              }
-              const itemResult = this.renderTokens(childTokens, itemContext, partials, originalTemplate, config, renderCache);
-              buffer += itemResult;
-            }
-          } else if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
-            const pushedContext = context.push(value);
-            if (context.renderCache) {
-              pushedContext.renderCache = context.renderCache;
-            }
-            buffer += this.renderTokens(childTokens, pushedContext, partials, originalTemplate, config, renderCache);
-          } else if (isFunction(value)) {
-            const text = originalTemplate == null ? null : originalTemplate.slice(token[3], token[5]);
-            value = value.call(context.view, text, (template) => this.render(template, context.view, partials, config));
-            if (value != null) buffer += value;
-          } else if (value) {
-            buffer += this.renderTokens(childTokens, context, partials, originalTemplate, config, renderCache);
-          }
-          break;
-        case "^":
-          value = context.lookup(token[1]);
-          if (!value || isArray(value) && value.length === 0) {
-            const childTokens2 = token[4];
-            if (childTokens2 && isArray(childTokens2)) {
-              buffer += this.renderTokens(childTokens2, context, partials, originalTemplate, config, renderCache);
-            }
-          }
-          break;
-        case ">":
-          if (!partials) continue;
-          value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
-          if (value != null) {
-            buffer += this.render(value, context.view, partials, config);
-          }
-          break;
-        case "&":
-          value = context.lookup(token[1]);
-          if (value != null) buffer += value;
-          break;
-        case "name":
-          value = context.lookup(token[1]);
-          if (value != null) buffer += escapeHtml(value);
-          break;
-        case "text":
-          buffer += token[1];
-          break;
-      }
-    }
-    return buffer;
-  }
-  getConfigTags(config) {
-    if (isObject(config) && isArray(config.tags)) {
-      return config.tags;
-    }
-    return null;
-  }
-}
-function escapeRegExp(string) {
-  return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
-}
-const defaultWriter = new Writer();
-const Mustache = {
-  name: "MOJO Mustache",
-  version: "1.0.0",
-  tags: ["{{", "}}"],
-  Scanner,
-  Context,
-  Writer,
-  escape: escapeHtml,
-  clearCache() {
-    return defaultWriter.clearCache();
-  },
-  parse(template, tags) {
-    return defaultWriter.parse(template, tags);
-  },
-  render(template, view, partials, config) {
-    if (typeof template !== "string") {
-      throw new TypeError('Invalid template! Template should be a "string"');
-    }
-    return defaultWriter.render(template, view, partials, config);
-  }
-};
 const GENERIC_AVATAR_SVG = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0iI2NlZDRkYSI+PHBhdGggZD0iTTEyIDEyYzIuMjEgMCA0LTEuNzkgNC00cy0xLjc5LTQtNC00LTQgMS43OS00IDQgMS43OSA0IDQgNHptMCAyYy0yLjY3IDAtOCAxLjM0LTggNHYyaDE2di0yYzAtMi42Ni01LjMzLTQtOC00eiIvPjwvc3ZnPg==";
 class DataFormatter {
   constructor() {
@@ -2253,173 +1796,629 @@ class MOJOUtils {
       numbers = numbers.replace(/[01]/g, "");
       specialChars = specialChars.replace(/[|]/g, "");
     }
-    let charPool = "";
-    const requiredChars = [];
-    if (config.customChars) {
-      charPool = config.customChars;
-    } else {
-      if (config.includeLowercase) {
-        charPool += lowercase;
-        requiredChars.push(lowercase[Math.floor(Math.random() * lowercase.length)]);
+    let charPool = "";
+    const requiredChars = [];
+    if (config.customChars) {
+      charPool = config.customChars;
+    } else {
+      if (config.includeLowercase) {
+        charPool += lowercase;
+        requiredChars.push(lowercase[Math.floor(Math.random() * lowercase.length)]);
+      }
+      if (config.includeUppercase) {
+        charPool += uppercase;
+        requiredChars.push(uppercase[Math.floor(Math.random() * uppercase.length)]);
+      }
+      if (config.includeNumbers) {
+        charPool += numbers;
+        requiredChars.push(numbers[Math.floor(Math.random() * numbers.length)]);
+      }
+      if (config.includeSpecialChars) {
+        charPool += specialChars;
+        requiredChars.push(specialChars[Math.floor(Math.random() * specialChars.length)]);
+      }
+    }
+    if (!charPool) {
+      throw new Error("No character types selected for password generation");
+    }
+    let password = "";
+    for (const char of requiredChars) {
+      password += char;
+    }
+    for (let i = password.length; i < config.length; i++) {
+      password += charPool[Math.floor(Math.random() * charPool.length)];
+    }
+    return password.split("").sort(() => Math.random() - 0.5).join("");
+  }
+  /**
+   * Parse query string into object
+   * @param {string} queryString - Query string to parse
+   * @returns {object} Parsed query parameters
+   */
+  static parseQueryString(queryString) {
+    const params = {};
+    const searchParams = new URLSearchParams(queryString);
+    for (const [key, value] of searchParams.entries()) {
+      params[key] = value;
+    }
+    return params;
+  }
+  /**
+   * Convert object to query string
+   * @param {object} params - Parameters object
+   * @returns {string} Query string
+   */
+  static toQueryString(params) {
+    return new URLSearchParams(params).toString();
+  }
+  /**
+   * Wrap data objects to provide get() method support
+   * This ensures pipe formatting works in all contexts
+   * @param {*} data - Data to wrap
+   * @param {object} rootContext - Optional root context for nested access
+   * @returns {*} Wrapped data if object/array, otherwise original
+   */
+  static wrapData(data, rootContext = null, depth = 3) {
+    if (!data || typeof data !== "object") {
+      return data;
+    }
+    if (data instanceof Date || data instanceof RegExp || data instanceof Error) {
+      return data;
+    }
+    if (depth <= 0) {
+      return data;
+    }
+    if (typeof data.getContextValue === "function") {
+      return data;
+    }
+    if (Array.isArray(data)) {
+      return data.map((item) => {
+        if (item && typeof item === "object" && !item.getContextValue) {
+          return new DataWrapper(item, rootContext);
+        }
+        return item;
+      });
+    }
+    return new DataWrapper(data, rootContext);
+  }
+}
+class DataWrapper {
+  constructor(data, rootContext = null) {
+    Object.defineProperty(this, "_data", {
+      value: data,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    Object.defineProperty(this, "_rootContext", {
+      value: rootContext,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    if (data && typeof data === "object") {
+      for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+          const value = data[key];
+          this[key] = MOJOUtils.wrapData(value, rootContext);
+        }
+      }
+    }
+  }
+  /**
+   * Get value with pipe support
+   * @param {string} key - Key with optional pipes
+   * @returns {*} Value, possibly formatted
+   */
+  getContextValue(key) {
+    let field = key;
+    let pipes = "";
+    let parenDepth = 0;
+    let pipeIndex = -1;
+    for (let i = 0; i < key.length; i++) {
+      const char = key[i];
+      if (char === "(") parenDepth++;
+      else if (char === ")") parenDepth--;
+      else if (char === "|" && parenDepth === 0) {
+        pipeIndex = i;
+        break;
+      }
+    }
+    if (pipeIndex > -1) {
+      field = key.substring(0, pipeIndex).trim();
+      pipes = key.substring(pipeIndex + 1).trim();
+    }
+    let value;
+    if (field in this && field !== "_data" && field !== "_rootContext") {
+      value = this[field];
+    } else {
+      value = MOJOUtils.getNestedValue(this._data, field);
+    }
+    if (pipes && value !== void 0) {
+      return dataFormatter.pipe(value, pipes, this._rootContext || this._data);
+    }
+    return value;
+  }
+  /**
+   * Check if wrapper has a property
+   * @param {string} key - Property key
+   * @returns {boolean} True if property exists
+   */
+  has(key) {
+    return this._data && this._data.hasOwnProperty(key);
+  }
+  /**
+   * Get the raw wrapped data
+   * @returns {object} The original data object
+   */
+  toJSON() {
+    return this._data;
+  }
+}
+MOJOUtils.DataWrapper = DataWrapper;
+if (typeof window !== "undefined") {
+  window.utils = MOJOUtils;
+}
+const objectToString = Object.prototype.toString;
+const isArray = Array.isArray || function(obj) {
+  return objectToString.call(obj) === "[object Array]";
+};
+const isFunction = function(obj) {
+  return typeof obj === "function";
+};
+const isObject = function(obj) {
+  return obj != null && typeof obj === "object";
+};
+const escapeHtml = function(string) {
+  const entityMap = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+    "/": "&#x2F;",
+    "`": "&#x60;",
+    "=": "&#x3D;"
+  };
+  return String(string).replace(/[&<>"'`=\/]/g, function(s) {
+    return entityMap[s];
+  });
+};
+class Scanner {
+  constructor(string) {
+    this.string = string;
+    this.tail = string;
+    this.pos = 0;
+  }
+  eos() {
+    return this.tail === "";
+  }
+  scan(re) {
+    const match = this.tail.match(re);
+    if (!match || match.index !== 0) {
+      return "";
+    }
+    const string = match[0];
+    this.tail = this.tail.substring(string.length);
+    this.pos += string.length;
+    return string;
+  }
+  scanUntil(re) {
+    const index = this.tail.search(re);
+    let match;
+    switch (index) {
+      case -1:
+        match = this.tail;
+        this.tail = "";
+        break;
+      case 0:
+        match = "";
+        break;
+      default:
+        match = this.tail.substring(0, index);
+        this.tail = this.tail.substring(index);
+    }
+    this.pos += match.length;
+    return match;
+  }
+}
+class Context {
+  constructor(view, parentContext) {
+    this.view = view;
+    this.cache = { ".": this.view };
+    this.parent = parentContext;
+    if (!this.view?._cacheId) {
+      if (this.view && typeof this.view === "object") {
+        this.view._cacheId = Math.random().toString(36).substring(2);
       }
-      if (config.includeUppercase) {
-        charPool += uppercase;
-        requiredChars.push(uppercase[Math.floor(Math.random() * uppercase.length)]);
+    }
+  }
+  push(view) {
+    return new Context(view, this);
+  }
+  lookup(name) {
+    if (this.renderCache && this.view?._cacheId) {
+      const cacheKey = `${this.view._cacheId}:${name}`;
+      if (this.renderCache.has(cacheKey)) {
+        return this.renderCache.get(cacheKey);
       }
-      if (config.includeNumbers) {
-        charPool += numbers;
-        requiredChars.push(numbers[Math.floor(Math.random() * numbers.length)]);
+    }
+    if (name === ".") {
+      return this.view;
+    }
+    if (name && name.startsWith(".")) {
+      let actualName = name.substring(1);
+      let shouldIterate = false;
+      if (actualName.endsWith("|iter")) {
+        actualName = actualName.substring(0, actualName.length - 5);
+        shouldIterate = true;
       }
-      if (config.includeSpecialChars) {
-        charPool += specialChars;
-        requiredChars.push(specialChars[Math.floor(Math.random() * specialChars.length)]);
+      if (this.view && typeof this.view === "object") {
+        let value2;
+        if (typeof this.view.getContextValue === "function") {
+          try {
+            value2 = this.view.getContextValue(actualName);
+            if (value2 !== void 0) {
+              if (isFunction(value2)) {
+                value2 = value2.call(this.view);
+              }
+            }
+          } catch (e) {
+            value2 = void 0;
+          }
+        }
+        if (value2 === void 0 && actualName in this.view) {
+          value2 = this.view[actualName];
+          if (isFunction(value2)) {
+            value2 = value2.call(this.view);
+          }
+        }
+        if (isArray(value2)) {
+          if (shouldIterate) {
+            return value2;
+          } else {
+            return value2.length > 0;
+          }
+        }
+        if (isObject(value2)) {
+          if (shouldIterate) {
+            return Object.entries(value2).map(([key, val]) => ({
+              key,
+              value: val
+            }));
+          } else {
+            return Object.keys(value2).length > 0;
+          }
+        }
+        return value2;
       }
+      return void 0;
     }
-    if (!charPool) {
-      throw new Error("No character types selected for password generation");
-    }
-    let password = "";
-    for (const char of requiredChars) {
-      password += char;
+    const cache = this.cache;
+    let value;
+    if (cache.hasOwnProperty(name)) {
+      value = cache[name];
+    } else {
+      let context = this;
+      let intermediateValue;
+      let names;
+      let index;
+      let lookupHit = false;
+      while (context) {
+        if (context.view && typeof context.view.getContextValue === "function") {
+          try {
+            intermediateValue = context.view.getContextValue(name);
+            if (intermediateValue !== void 0) {
+              lookupHit = true;
+            }
+          } catch (e) {
+            lookupHit = false;
+          }
+        }
+        if (!lookupHit) {
+          if (name.indexOf(".") > 0) {
+            intermediateValue = context.view;
+            names = name.split(".");
+            index = 0;
+            while (intermediateValue != null && index < names.length) {
+              if (intermediateValue && typeof intermediateValue.getContextValue === "function" && index < names.length) {
+                try {
+                  const remainingPath = names.slice(index).join(".");
+                  intermediateValue = intermediateValue.getContextValue(remainingPath);
+                  index = names.length;
+                  if (intermediateValue !== void 0) {
+                    lookupHit = true;
+                  }
+                } catch (e) {
+                  if (index === names.length - 1) {
+                    lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
+                  }
+                  intermediateValue = intermediateValue[names[index++]];
+                }
+              } else {
+                if (index === names.length - 1) {
+                  lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
+                }
+                intermediateValue = intermediateValue[names[index++]];
+              }
+            }
+          } else {
+            intermediateValue = context.view[name];
+            lookupHit = hasProperty(context.view, name);
+          }
+        }
+        if (lookupHit) {
+          value = intermediateValue;
+          break;
+        }
+        context = context.parent;
+      }
+      cache[name] = value;
     }
-    for (let i = password.length; i < config.length; i++) {
-      password += charPool[Math.floor(Math.random() * charPool.length)];
+    if (isFunction(value)) value = value.call(this.view);
+    if (this.renderCache && this.view?._cacheId) {
+      const cacheKey = `${this.view._cacheId}:${name}`;
+      this.renderCache.set(cacheKey, value);
     }
-    return password.split("").sort(() => Math.random() - 0.5).join("");
+    return value;
   }
-  /**
-   * Parse query string into object
-   * @param {string} queryString - Query string to parse
-   * @returns {object} Parsed query parameters
-   */
-  static parseQueryString(queryString) {
-    const params = {};
-    const searchParams = new URLSearchParams(queryString);
-    for (const [key, value] of searchParams.entries()) {
-      params[key] = value;
-    }
-    return params;
+}
+function hasProperty(obj, propName) {
+  return obj != null && typeof obj === "object" && propName in obj;
+}
+function primitiveHasOwnProperty(primitive, propName) {
+  return primitive != null && typeof primitive !== "object" && primitive.hasOwnProperty && primitive.hasOwnProperty(propName);
+}
+class Writer {
+  constructor() {
+    this.templateCache = /* @__PURE__ */ new Map();
   }
-  /**
-   * Convert object to query string
-   * @param {object} params - Parameters object
-   * @returns {string} Query string
-   */
-  static toQueryString(params) {
-    return new URLSearchParams(params).toString();
+  clearCache() {
+    this.templateCache.clear();
   }
-  /**
-   * Wrap data objects to provide get() method support
-   * This ensures pipe formatting works in all contexts
-   * @param {*} data - Data to wrap
-   * @param {object} rootContext - Optional root context for nested access
-   * @returns {*} Wrapped data if object/array, otherwise original
-   */
-  static wrapData(data, rootContext = null, depth = 3) {
-    if (!data || typeof data !== "object") {
-      return data;
-    }
-    if (data instanceof Date || data instanceof RegExp || data instanceof Error) {
-      return data;
-    }
-    if (depth <= 0) {
-      return data;
-    }
-    if (typeof data.getContextValue === "function") {
-      return data;
+  parse(template, tags) {
+    tags = tags || ["{{", "}}"];
+    const cacheKey = template + ":" + tags.join(":");
+    let tokens = this.templateCache.get(cacheKey);
+    if (tokens == null) {
+      tokens = this.parseTemplate(template, tags);
+      this.templateCache.set(cacheKey, tokens);
     }
-    if (Array.isArray(data)) {
-      return data.map((item) => {
-        if (item && typeof item === "object" && !item.getContextValue) {
-          return new DataWrapper(item, rootContext);
+    return tokens;
+  }
+  parseTemplate(template, tags) {
+    if (!template) return [];
+    const openingTag = tags[0];
+    const closingTag = tags[1];
+    const scanner = new Scanner(template);
+    const tokens = [];
+    let start, type, value, chr, token;
+    const openingTagRe = new RegExp(escapeRegExp(openingTag) + "\\s*");
+    const closingTagRe = new RegExp("\\s*" + escapeRegExp(closingTag));
+    const closingCurlyRe = new RegExp("\\s*" + escapeRegExp("}" + closingTag));
+    while (!scanner.eos()) {
+      start = scanner.pos;
+      value = scanner.scanUntil(openingTagRe);
+      if (value) {
+        for (let i = 0; i < value.length; ++i) {
+          chr = value.charAt(i);
+          if (chr === "\n") {
+            tokens.push(["text", chr]);
+          } else {
+            tokens.push(["text", chr]);
+          }
+        }
+      }
+      if (!scanner.scan(openingTagRe)) break;
+      type = scanner.scan(/[#^\/>{&=!]/);
+      if (!type) type = "name";
+      scanner.scan(/\s*/);
+      if (type === "=") {
+        value = scanner.scanUntil(/\s*=/);
+        scanner.scan(/\s*=/);
+        scanner.scanUntil(closingTagRe);
+      } else if (type === "{") {
+        value = scanner.scanUntil(closingCurlyRe);
+        scanner.scan(closingCurlyRe);
+        type = "&";
+      } else {
+        value = scanner.scanUntil(closingTagRe);
+      }
+      scanner.scan(closingTagRe);
+      if (type === "#" || type === "^") {
+        token = [type, value, start, scanner.pos];
+        tokens.push(token);
+      } else if (type === "/") {
+        let openSection;
+        for (let i = tokens.length - 1; i >= 0; --i) {
+          if (tokens[i][0] === "#" || tokens[i][0] === "^") {
+            if (tokens[i][1] === value) {
+              openSection = tokens[i];
+              break;
+            }
+          }
         }
-        return item;
-      });
+        if (openSection) {
+          if (openSection.length === 4) {
+            openSection.push(scanner.pos);
+          }
+        }
+        tokens.push([type, value, start, scanner.pos]);
+      } else {
+        tokens.push([type, value, start, scanner.pos]);
+      }
     }
-    return new DataWrapper(data, rootContext);
+    return this.nestSections(this.squashTokens(tokens));
   }
-}
-class DataWrapper {
-  constructor(data, rootContext = null) {
-    Object.defineProperty(this, "_data", {
-      value: data,
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-    Object.defineProperty(this, "_rootContext", {
-      value: rootContext,
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-    if (data && typeof data === "object") {
-      for (const key in data) {
-        if (data.hasOwnProperty(key)) {
-          const value = data[key];
-          this[key] = MOJOUtils.wrapData(value, rootContext);
+  squashTokens(tokens) {
+    const squashedTokens = [];
+    let token, lastToken;
+    for (let i = 0; i < tokens.length; ++i) {
+      token = tokens[i];
+      if (token) {
+        if (token[0] === "text" && lastToken && lastToken[0] === "text") {
+          lastToken[1] += token[1];
+          lastToken[3] = token[3];
+        } else {
+          squashedTokens.push(token);
+          lastToken = token;
         }
       }
     }
+    return squashedTokens;
   }
-  /**
-   * Get value with pipe support
-   * @param {string} key - Key with optional pipes
-   * @returns {*} Value, possibly formatted
-   */
-  getContextValue(key) {
-    let field = key;
-    let pipes = "";
-    let parenDepth = 0;
-    let pipeIndex = -1;
-    for (let i = 0; i < key.length; i++) {
-      const char = key[i];
-      if (char === "(") parenDepth++;
-      else if (char === ")") parenDepth--;
-      else if (char === "|" && parenDepth === 0) {
-        pipeIndex = i;
-        break;
+  nestSections(tokens) {
+    const nestedTokens = [];
+    let collector = nestedTokens;
+    const sections = [];
+    for (let i = 0; i < tokens.length; ++i) {
+      const token = tokens[i];
+      switch (token[0]) {
+        case "#":
+        case "^":
+          const sectionToken = [
+            token[0],
+            // type ('#' or '^')
+            token[1],
+            // section name
+            token[2],
+            // start position
+            token[3],
+            // end position after opening tag
+            [],
+            // children array
+            token[4] || null
+            // closing position (if set during parsing)
+          ];
+          collector.push(sectionToken);
+          sections.push(sectionToken);
+          collector = sectionToken[4];
+          break;
+        case "/":
+          const section = sections.pop();
+          if (section) {
+            section[5] = token[2];
+            collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
+          }
+          break;
+        default:
+          collector.push(token);
       }
     }
-    if (pipeIndex > -1) {
-      field = key.substring(0, pipeIndex).trim();
-      pipes = key.substring(pipeIndex + 1).trim();
+    return nestedTokens;
+  }
+  render(template, view, partials, config) {
+    const tags = this.getConfigTags(config) || ["{{", "}}"];
+    const tokens = this.parse(template, tags);
+    const renderCache = /* @__PURE__ */ new Map();
+    return this.renderTokens(tokens, new Context(view), partials, template, config, renderCache);
+  }
+  renderTokens(tokens, context, partials, originalTemplate, config, renderCache) {
+    if (renderCache && !context.renderCache) {
+      context.renderCache = renderCache;
     }
-    let value;
-    if (this._data && this._data.hasOwnProperty(field)) {
-      if (field in this && field !== "_data" && field !== "_rootContext") {
-        value = this[field];
-      } else {
-        value = MOJOUtils.getNestedValue(this._data, field);
+    let buffer = "";
+    for (let i = 0; i < tokens.length; ++i) {
+      const token = tokens[i];
+      let value;
+      switch (token[0]) {
+        case "#":
+          value = context.lookup(token[1]);
+          if (!value) continue;
+          const childTokens = token[4];
+          if (!childTokens || !isArray(childTokens)) {
+            console.warn(`MUSTACHE WARNING - Section ${token[1]} has no child tokens:`, token);
+            continue;
+          }
+          if (isArray(value)) {
+            for (let j = 0; j < value.length; ++j) {
+              const itemContext = context.push(value[j]);
+              if (context.renderCache) {
+                itemContext.renderCache = context.renderCache;
+              }
+              const itemResult = this.renderTokens(childTokens, itemContext, partials, originalTemplate, config, renderCache);
+              buffer += itemResult;
+            }
+          } else if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
+            const pushedContext = context.push(value);
+            if (context.renderCache) {
+              pushedContext.renderCache = context.renderCache;
+            }
+            buffer += this.renderTokens(childTokens, pushedContext, partials, originalTemplate, config, renderCache);
+          } else if (isFunction(value)) {
+            const text = originalTemplate == null ? null : originalTemplate.slice(token[3], token[5]);
+            value = value.call(context.view, text, (template) => this.render(template, context.view, partials, config));
+            if (value != null) buffer += value;
+          } else if (value) {
+            buffer += this.renderTokens(childTokens, context, partials, originalTemplate, config, renderCache);
+          }
+          break;
+        case "^":
+          value = context.lookup(token[1]);
+          if (!value || isArray(value) && value.length === 0) {
+            const childTokens2 = token[4];
+            if (childTokens2 && isArray(childTokens2)) {
+              buffer += this.renderTokens(childTokens2, context, partials, originalTemplate, config, renderCache);
+            }
+          }
+          break;
+        case ">":
+          if (!partials) continue;
+          value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
+          if (value != null) {
+            buffer += this.render(value, context.view, partials, config);
+          }
+          break;
+        case "&":
+          value = context.lookup(token[1]);
+          if (value != null) buffer += value;
+          break;
+        case "name":
+          value = context.lookup(token[1]);
+          if (value != null) buffer += escapeHtml(value);
+          break;
+        case "text":
+          buffer += token[1];
+          break;
       }
-    } else {
-      value = void 0;
     }
-    if (pipes && value !== void 0) {
-      return dataFormatter.pipe(value, pipes, this._rootContext || this._data);
-    }
-    return value;
-  }
-  /**
-   * Check if wrapper has a property
-   * @param {string} key - Property key
-   * @returns {boolean} True if property exists
-   */
-  has(key) {
-    return this._data && this._data.hasOwnProperty(key);
+    return buffer;
   }
-  /**
-   * Get the raw wrapped data
-   * @returns {object} The original data object
-   */
-  toJSON() {
-    return this._data;
+  getConfigTags(config) {
+    if (isObject(config) && isArray(config.tags)) {
+      return config.tags;
+    }
+    return null;
   }
 }
-MOJOUtils.DataWrapper = DataWrapper;
-if (typeof window !== "undefined") {
-  window.utils = MOJOUtils;
+function escapeRegExp(string) {
+  return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
 }
+const defaultWriter = new Writer();
+const Mustache = {
+  name: "MOJO Mustache",
+  version: "1.0.0",
+  tags: ["{{", "}}"],
+  Scanner,
+  Context,
+  Writer,
+  escape: escapeHtml,
+  clearCache() {
+    return defaultWriter.clearCache();
+  },
+  parse(template, tags) {
+    return defaultWriter.parse(template, tags);
+  },
+  render(template, view, partials, config) {
+    if (typeof template !== "string") {
+      throw new TypeError('Invalid template! Template should be a "string"');
+    }
+    if (view && typeof view === "object" && !view.getContextValue && typeof view.toJSON !== "function") {
+      view = MOJOUtils.wrapData(view);
+    }
+    return defaultWriter.render(template, view, partials, config);
+  }
+};
 class EventDelegate {
   constructor(view) {
     this.view = view;
@@ -4133,4 +4132,4 @@ export {
   dataFormatter as d,
   rest as r
 };
-//# sourceMappingURL=Rest-DpbPbmra.js.map
+//# sourceMappingURL=Rest-C3KvOEeY.js.map