@learncard/network-plugin 2.9.0 → 2.9.2

package/dist/lcn-plugin.esm.js

@@ -712,9 +712,9 @@ function maybeFreeze(scope, value, deep = false) {
 __name(maybeFreeze, "maybeFreeze");
 __name2(maybeFreeze, "maybeFreeze");
 function createProxyProxy(base, parent) {
-  const isArray = Array.isArray(base);
+  const isArray2 = Array.isArray(base);
   const state = {
-    type_: isArray ? 1 : 0,
+    type_: isArray2 ? 1 : 0,
     // Track which produce call this is associated with.
     scope_: parent ? parent.scope_ : getCurrentScope(),
     // True for both shallow and deep changes.
@@ -738,7 +738,7 @@ function createProxyProxy(base, parent) {
   };
   let target = state;
   let traps = objectTraps;
-  if (isArray) {
+  if (isArray2) {
     target = [state];
     traps = arrayTraps;
   }
@@ -29506,7 +29506,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       contractUri: external_exports22.string().optional(),
       templateUri: external_exports22.string().optional(),
       template: SendBoostTemplateValidator2.optional(),
-      signedCredential: VCValidator2.optional()
+      signedCredential: VCValidator2.optional(),
+      templateData: external_exports22.record(external_exports22.string(), external_exports22.unknown()).optional()
     }).refine((data) => data.templateUri || data.template, {
       message: "Either templateUri or template creation data must be provided.",
       path: ["templateUri"]
@@ -30503,16 +30504,16 @@ function parserForArrayFormat(options) {
     case "comma":
     case "separator": {
       return (key, value, accumulator) => {
-        const isArray = typeof value === "string" && value.includes(options.arrayFormatSeparator);
-        const newValue = isArray ? value.split(options.arrayFormatSeparator).map((item) => decode3(item, options)) : value === null ? value : decode3(value, options);
+        const isArray2 = typeof value === "string" && value.includes(options.arrayFormatSeparator);
+        const newValue = isArray2 ? value.split(options.arrayFormatSeparator).map((item) => decode3(item, options)) : value === null ? value : decode3(value, options);
         accumulator[key] = newValue;
       };
     }
     case "bracket-separator": {
       return (key, value, accumulator) => {
-        const isArray = /(\[])$/.test(key);
+        const isArray2 = /(\[])$/.test(key);
         key = key.replace(/\[]$/, "");
-        if (!isArray) {
+        if (!isArray2) {
           accumulator[key] = value ? decode3(value, options) : value;
           return;
         }
@@ -46106,7 +46107,8 @@ var SendBoostInputValidator = external_exports2.object({
   contractUri: external_exports2.string().optional(),
   templateUri: external_exports2.string().optional(),
   template: SendBoostTemplateValidator.optional(),
-  signedCredential: VCValidator.optional()
+  signedCredential: VCValidator.optional(),
+  templateData: external_exports2.record(external_exports2.string(), external_exports2.unknown()).optional()
 }).refine((data) => data.templateUri || data.template, {
   message: "Either templateUri or template creation data must be provided.",
   path: ["templateUri"]
@@ -47243,9 +47245,9 @@ function maybeFreeze2(scope, value, deep = false) {
 }
 __name(maybeFreeze2, "maybeFreeze");
 function createProxyProxy2(base, parent) {
-  const isArray = Array.isArray(base);
+  const isArray2 = Array.isArray(base);
   const state = {
-    type_: isArray ? 1 : 0,
+    type_: isArray2 ? 1 : 0,
     // Track which produce call this is associated with.
     scope_: parent ? parent.scope_ : getCurrentScope2(),
     // True for both shallow and deep changes.
@@ -47269,7 +47271,7 @@ function createProxyProxy2(base, parent) {
   };
   let target = state;
   let traps = objectTraps2;
-  if (isArray) {
+  if (isArray2) {
     target = [state];
     traps = arrayTraps2;
   }
@@ -62293,7 +62295,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       contractUri: external_exports3.string().optional(),
       templateUri: external_exports3.string().optional(),
       template: SendBoostTemplateValidator2.optional(),
-      signedCredential: VCValidator2.optional()
+      signedCredential: VCValidator2.optional(),
+      templateData: external_exports3.record(external_exports3.string(), external_exports3.unknown()).optional()
     }).refine((data) => data.templateUri || data.template, {
       message: "Either templateUri or template creation data must be provided.",
       path: ["templateUri"]
@@ -63289,16 +63292,16 @@ function parserForArrayFormat2(options) {
     case "comma":
     case "separator": {
       return (key, value, accumulator) => {
-        const isArray = typeof value === "string" && value.includes(options.arrayFormatSeparator);
-        const newValue = isArray ? value.split(options.arrayFormatSeparator).map((item) => decode6(item, options)) : value === null ? value : decode6(value, options);
+        const isArray2 = typeof value === "string" && value.includes(options.arrayFormatSeparator);
+        const newValue = isArray2 ? value.split(options.arrayFormatSeparator).map((item) => decode6(item, options)) : value === null ? value : decode6(value, options);
         accumulator[key] = newValue;
       };
     }
     case "bracket-separator": {
       return (key, value, accumulator) => {
-        const isArray = /(\[])$/.test(key);
+        const isArray2 = /(\[])$/.test(key);
         key = key.replace(/\[]$/, "");
-        if (!isArray) {
+        if (!isArray2) {
           accumulator[key] = value ? decode6(value, options) : value;
           return;
         }
@@ -63769,7 +63772,494 @@ var isVC2Format = /* @__PURE__ */ __name4((credential) => {
   return credential["@context"].includes("https://www.w3.org/ns/credentials/v2");
 }, "isVC2Format");
 
+// ../../../node_modules/.pnpm/mustache@4.2.0/node_modules/mustache/mustache.mjs
+var objectToString = Object.prototype.toString;
+var isArray = Array.isArray || /* @__PURE__ */ __name(function isArrayPolyfill(object3) {
+  return objectToString.call(object3) === "[object Array]";
+}, "isArrayPolyfill");
+function isFunction(object3) {
+  return typeof object3 === "function";
+}
+__name(isFunction, "isFunction");
+function typeStr(obj) {
+  return isArray(obj) ? "array" : typeof obj;
+}
+__name(typeStr, "typeStr");
+function escapeRegExp(string7) {
+  return string7.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function hasProperty(obj, propName) {
+  return obj != null && typeof obj === "object" && propName in obj;
+}
+__name(hasProperty, "hasProperty");
+function primitiveHasOwnProperty(primitive, propName) {
+  return primitive != null && typeof primitive !== "object" && primitive.hasOwnProperty && primitive.hasOwnProperty(propName);
+}
+__name(primitiveHasOwnProperty, "primitiveHasOwnProperty");
+var regExpTest = RegExp.prototype.test;
+function testRegExp(re, string7) {
+  return regExpTest.call(re, string7);
+}
+__name(testRegExp, "testRegExp");
+var nonSpaceRe = /\S/;
+function isWhitespace(string7) {
+  return !testRegExp(nonSpaceRe, string7);
+}
+__name(isWhitespace, "isWhitespace");
+var entityMap = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+  "/": "&#x2F;",
+  "`": "&#x60;",
+  "=": "&#x3D;"
+};
+function escapeHtml(string7) {
+  return String(string7).replace(/[&<>"'`=\/]/g, /* @__PURE__ */ __name(function fromEntityMap(s) {
+    return entityMap[s];
+  }, "fromEntityMap"));
+}
+__name(escapeHtml, "escapeHtml");
+var whiteRe = /\s*/;
+var spaceRe = /\s+/;
+var equalsRe = /\s*=/;
+var curlyRe = /\s*\}/;
+var tagRe = /#|\^|\/|>|\{|&|=|!/;
+function parseTemplate(template, tags) {
+  if (!template)
+    return [];
+  var lineHasNonSpace = false;
+  var sections = [];
+  var tokens = [];
+  var spaces = [];
+  var hasTag = false;
+  var nonSpace = false;
+  var indentation = "";
+  var tagIndex = 0;
+  function stripSpace() {
+    if (hasTag && !nonSpace) {
+      while (spaces.length)
+        delete tokens[spaces.pop()];
+    } else {
+      spaces = [];
+    }
+    hasTag = false;
+    nonSpace = false;
+  }
+  __name(stripSpace, "stripSpace");
+  var openingTagRe, closingTagRe, closingCurlyRe;
+  function compileTags(tagsToCompile) {
+    if (typeof tagsToCompile === "string")
+      tagsToCompile = tagsToCompile.split(spaceRe, 2);
+    if (!isArray(tagsToCompile) || tagsToCompile.length !== 2)
+      throw new Error("Invalid tags: " + tagsToCompile);
+    openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + "\\s*");
+    closingTagRe = new RegExp("\\s*" + escapeRegExp(tagsToCompile[1]));
+    closingCurlyRe = new RegExp("\\s*" + escapeRegExp("}" + tagsToCompile[1]));
+  }
+  __name(compileTags, "compileTags");
+  compileTags(tags || mustache.tags);
+  var scanner = new Scanner(template);
+  var start, type, value, chr, token, openSection;
+  while (!scanner.eos()) {
+    start = scanner.pos;
+    value = scanner.scanUntil(openingTagRe);
+    if (value) {
+      for (var i = 0, valueLength = value.length; i < valueLength; ++i) {
+        chr = value.charAt(i);
+        if (isWhitespace(chr)) {
+          spaces.push(tokens.length);
+          indentation += chr;
+        } else {
+          nonSpace = true;
+          lineHasNonSpace = true;
+          indentation += " ";
+        }
+        tokens.push(["text", chr, start, start + 1]);
+        start += 1;
+        if (chr === "\n") {
+          stripSpace();
+          indentation = "";
+          tagIndex = 0;
+          lineHasNonSpace = false;
+        }
+      }
+    }
+    if (!scanner.scan(openingTagRe))
+      break;
+    hasTag = true;
+    type = scanner.scan(tagRe) || "name";
+    scanner.scan(whiteRe);
+    if (type === "=") {
+      value = scanner.scanUntil(equalsRe);
+      scanner.scan(equalsRe);
+      scanner.scanUntil(closingTagRe);
+    } else if (type === "{") {
+      value = scanner.scanUntil(closingCurlyRe);
+      scanner.scan(curlyRe);
+      scanner.scanUntil(closingTagRe);
+      type = "&";
+    } else {
+      value = scanner.scanUntil(closingTagRe);
+    }
+    if (!scanner.scan(closingTagRe))
+      throw new Error("Unclosed tag at " + scanner.pos);
+    if (type == ">") {
+      token = [type, value, start, scanner.pos, indentation, tagIndex, lineHasNonSpace];
+    } else {
+      token = [type, value, start, scanner.pos];
+    }
+    tagIndex++;
+    tokens.push(token);
+    if (type === "#" || type === "^") {
+      sections.push(token);
+    } else if (type === "/") {
+      openSection = sections.pop();
+      if (!openSection)
+        throw new Error('Unopened section "' + value + '" at ' + start);
+      if (openSection[1] !== value)
+        throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
+    } else if (type === "name" || type === "{" || type === "&") {
+      nonSpace = true;
+    } else if (type === "=") {
+      compileTags(value);
+    }
+  }
+  stripSpace();
+  openSection = sections.pop();
+  if (openSection)
+    throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
+  return nestTokens(squashTokens(tokens));
+}
+__name(parseTemplate, "parseTemplate");
+function squashTokens(tokens) {
+  var squashedTokens = [];
+  var token, lastToken;
+  for (var i = 0, numTokens = tokens.length; i < numTokens; ++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;
+}
+__name(squashTokens, "squashTokens");
+function nestTokens(tokens) {
+  var nestedTokens = [];
+  var collector = nestedTokens;
+  var sections = [];
+  var token, section;
+  for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+    token = tokens[i];
+    switch (token[0]) {
+      case "#":
+      case "^":
+        collector.push(token);
+        sections.push(token);
+        collector = token[4] = [];
+        break;
+      case "/":
+        section = sections.pop();
+        section[5] = token[2];
+        collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
+        break;
+      default:
+        collector.push(token);
+    }
+  }
+  return nestedTokens;
+}
+__name(nestTokens, "nestTokens");
+function Scanner(string7) {
+  this.string = string7;
+  this.tail = string7;
+  this.pos = 0;
+}
+__name(Scanner, "Scanner");
+Scanner.prototype.eos = /* @__PURE__ */ __name(function eos() {
+  return this.tail === "";
+}, "eos");
+Scanner.prototype.scan = /* @__PURE__ */ __name(function scan(re) {
+  var match = this.tail.match(re);
+  if (!match || match.index !== 0)
+    return "";
+  var string7 = match[0];
+  this.tail = this.tail.substring(string7.length);
+  this.pos += string7.length;
+  return string7;
+}, "scan");
+Scanner.prototype.scanUntil = /* @__PURE__ */ __name(function scanUntil(re) {
+  var index = this.tail.search(re), 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;
+}, "scanUntil");
+function Context(view, parentContext) {
+  this.view = view;
+  this.cache = { ".": this.view };
+  this.parent = parentContext;
+}
+__name(Context, "Context");
+Context.prototype.push = /* @__PURE__ */ __name(function push(view) {
+  return new Context(view, this);
+}, "push");
+Context.prototype.lookup = /* @__PURE__ */ __name(function lookup(name) {
+  var cache = this.cache;
+  var value;
+  if (cache.hasOwnProperty(name)) {
+    value = cache[name];
+  } else {
+    var context = this, intermediateValue, names, index, lookupHit = false;
+    while (context) {
+      if (name.indexOf(".") > 0) {
+        intermediateValue = context.view;
+        names = name.split(".");
+        index = 0;
+        while (intermediateValue != null && index < names.length) {
+          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);
+  return value;
+}, "lookup");
+function Writer() {
+  this.templateCache = {
+    _cache: {},
+    set: /* @__PURE__ */ __name(function set5(key, value) {
+      this._cache[key] = value;
+    }, "set"),
+    get: /* @__PURE__ */ __name(function get(key) {
+      return this._cache[key];
+    }, "get"),
+    clear: /* @__PURE__ */ __name(function clear() {
+      this._cache = {};
+    }, "clear")
+  };
+}
+__name(Writer, "Writer");
+Writer.prototype.clearCache = /* @__PURE__ */ __name(function clearCache() {
+  if (typeof this.templateCache !== "undefined") {
+    this.templateCache.clear();
+  }
+}, "clearCache");
+Writer.prototype.parse = /* @__PURE__ */ __name(function parse7(template, tags) {
+  var cache = this.templateCache;
+  var cacheKey = template + ":" + (tags || mustache.tags).join(":");
+  var isCacheEnabled = typeof cache !== "undefined";
+  var tokens = isCacheEnabled ? cache.get(cacheKey) : void 0;
+  if (tokens == void 0) {
+    tokens = parseTemplate(template, tags);
+    isCacheEnabled && cache.set(cacheKey, tokens);
+  }
+  return tokens;
+}, "parse");
+Writer.prototype.render = /* @__PURE__ */ __name(function render(template, view, partials, config3) {
+  var tags = this.getConfigTags(config3);
+  var tokens = this.parse(template, tags);
+  var context = view instanceof Context ? view : new Context(view, void 0);
+  return this.renderTokens(tokens, context, partials, template, config3);
+}, "render");
+Writer.prototype.renderTokens = /* @__PURE__ */ __name(function renderTokens(tokens, context, partials, originalTemplate, config3) {
+  var buffer = "";
+  var token, symbol3, value;
+  for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+    value = void 0;
+    token = tokens[i];
+    symbol3 = token[0];
+    if (symbol3 === "#") value = this.renderSection(token, context, partials, originalTemplate, config3);
+    else if (symbol3 === "^") value = this.renderInverted(token, context, partials, originalTemplate, config3);
+    else if (symbol3 === ">") value = this.renderPartial(token, context, partials, config3);
+    else if (symbol3 === "&") value = this.unescapedValue(token, context);
+    else if (symbol3 === "name") value = this.escapedValue(token, context, config3);
+    else if (symbol3 === "text") value = this.rawValue(token);
+    if (value !== void 0)
+      buffer += value;
+  }
+  return buffer;
+}, "renderTokens");
+Writer.prototype.renderSection = /* @__PURE__ */ __name(function renderSection(token, context, partials, originalTemplate, config3) {
+  var self = this;
+  var buffer = "";
+  var value = context.lookup(token[1]);
+  function subRender(template) {
+    return self.render(template, context, partials, config3);
+  }
+  __name(subRender, "subRender");
+  if (!value) return;
+  if (isArray(value)) {
+    for (var j = 0, valueLength = value.length; j < valueLength; ++j) {
+      buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate, config3);
+    }
+  } else if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
+    buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate, config3);
+  } else if (isFunction(value)) {
+    if (typeof originalTemplate !== "string")
+      throw new Error("Cannot use higher-order sections without the original template");
+    value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);
+    if (value != null)
+      buffer += value;
+  } else {
+    buffer += this.renderTokens(token[4], context, partials, originalTemplate, config3);
+  }
+  return buffer;
+}, "renderSection");
+Writer.prototype.renderInverted = /* @__PURE__ */ __name(function renderInverted(token, context, partials, originalTemplate, config3) {
+  var value = context.lookup(token[1]);
+  if (!value || isArray(value) && value.length === 0)
+    return this.renderTokens(token[4], context, partials, originalTemplate, config3);
+}, "renderInverted");
+Writer.prototype.indentPartial = /* @__PURE__ */ __name(function indentPartial(partial3, indentation, lineHasNonSpace) {
+  var filteredIndentation = indentation.replace(/[^ \t]/g, "");
+  var partialByNl = partial3.split("\n");
+  for (var i = 0; i < partialByNl.length; i++) {
+    if (partialByNl[i].length && (i > 0 || !lineHasNonSpace)) {
+      partialByNl[i] = filteredIndentation + partialByNl[i];
+    }
+  }
+  return partialByNl.join("\n");
+}, "indentPartial");
+Writer.prototype.renderPartial = /* @__PURE__ */ __name(function renderPartial(token, context, partials, config3) {
+  if (!partials) return;
+  var tags = this.getConfigTags(config3);
+  var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
+  if (value != null) {
+    var lineHasNonSpace = token[6];
+    var tagIndex = token[5];
+    var indentation = token[4];
+    var indentedValue = value;
+    if (tagIndex == 0 && indentation) {
+      indentedValue = this.indentPartial(value, indentation, lineHasNonSpace);
+    }
+    var tokens = this.parse(indentedValue, tags);
+    return this.renderTokens(tokens, context, partials, indentedValue, config3);
+  }
+}, "renderPartial");
+Writer.prototype.unescapedValue = /* @__PURE__ */ __name(function unescapedValue(token, context) {
+  var value = context.lookup(token[1]);
+  if (value != null)
+    return value;
+}, "unescapedValue");
+Writer.prototype.escapedValue = /* @__PURE__ */ __name(function escapedValue(token, context, config3) {
+  var escape = this.getConfigEscape(config3) || mustache.escape;
+  var value = context.lookup(token[1]);
+  if (value != null)
+    return typeof value === "number" && escape === mustache.escape ? String(value) : escape(value);
+}, "escapedValue");
+Writer.prototype.rawValue = /* @__PURE__ */ __name(function rawValue(token) {
+  return token[1];
+}, "rawValue");
+Writer.prototype.getConfigTags = /* @__PURE__ */ __name(function getConfigTags(config3) {
+  if (isArray(config3)) {
+    return config3;
+  } else if (config3 && typeof config3 === "object") {
+    return config3.tags;
+  } else {
+    return void 0;
+  }
+}, "getConfigTags");
+Writer.prototype.getConfigEscape = /* @__PURE__ */ __name(function getConfigEscape(config3) {
+  if (config3 && typeof config3 === "object" && !isArray(config3)) {
+    return config3.escape;
+  } else {
+    return void 0;
+  }
+}, "getConfigEscape");
+var mustache = {
+  name: "mustache.js",
+  version: "4.2.0",
+  tags: ["{{", "}}"],
+  clearCache: void 0,
+  escape: void 0,
+  parse: void 0,
+  render: void 0,
+  Scanner: void 0,
+  Context: void 0,
+  Writer: void 0,
+  /**
+   * Allows a user to override the default caching strategy, by providing an
+   * object with set, get and clear methods. This can also be used to disable
+   * the cache by setting it to the literal `undefined`.
+   */
+  set templateCache(cache) {
+    defaultWriter.templateCache = cache;
+  },
+  /**
+   * Gets the default or overridden caching object from the default writer.
+   */
+  get templateCache() {
+    return defaultWriter.templateCache;
+  }
+};
+var defaultWriter = new Writer();
+mustache.clearCache = /* @__PURE__ */ __name(function clearCache2() {
+  return defaultWriter.clearCache();
+}, "clearCache");
+mustache.parse = /* @__PURE__ */ __name(function parse8(template, tags) {
+  return defaultWriter.parse(template, tags);
+}, "parse");
+mustache.render = /* @__PURE__ */ __name(function render2(template, view, partials, config3) {
+  if (typeof template !== "string") {
+    throw new TypeError('Invalid template! Template should be a "string" but "' + typeStr(template) + '" was given as the first argument for mustache#render(template, view, partials)');
+  }
+  return defaultWriter.render(template, view, partials, config3);
+}, "render");
+mustache.escape = escapeHtml;
+mustache.Scanner = Scanner;
+mustache.Context = Context;
+mustache.Writer = Writer;
+var mustache_default = mustache;
+
 // src/plugin.ts
+var escapeJsonStringValue = /* @__PURE__ */ __name((value) => {
+  if (value === null || value === void 0) return "";
+  return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\f/g, "\\f").replace(/[\b]/g, "\\b");
+}, "escapeJsonStringValue");
+var prepareTemplateData = /* @__PURE__ */ __name((templateData) => {
+  const prepared = {};
+  for (const [key, value] of Object.entries(templateData)) {
+    prepared[key] = escapeJsonStringValue(value);
+  }
+  return prepared;
+}, "prepareTemplateData");
+var renderTemplateJson = /* @__PURE__ */ __name((jsonString, templateData) => {
+  const preparedData = prepareTemplateData(templateData);
+  const unescapedTemplate = jsonString.replace(/\{\{([^{}]+)\}\}/g, "{{{$1}}}");
+  return mustache_default.render(unescapedTemplate, preparedData);
+}, "renderTemplateJson");
 async function getLearnCardNetworkPlugin(learnCard, url3, apiToken) {
   let did = "";
   try {
@@ -64351,7 +64841,7 @@ async function getLearnCardNetworkPlugin(learnCard, url3, apiToken) {
         await ensureUser();
         return client.boost.deleteBoost.mutate({ uri });
       }, "deleteBoost"),
-      sendBoost: /* @__PURE__ */ __name(async (_learnCard, profileId, boostUri, options = { encrypt: true, skipNotification: false }) => {
+      sendBoost: /* @__PURE__ */ __name(async (_learnCard, profileId, boostUri, options = { encrypt: true, skipNotification: false, templateData: {} }) => {
         await ensureUser();
         const result = await _learnCard.invoke.resolveFromLCN(boostUri);
         const data = await UnsignedVCValidator.spa(result);
@@ -64374,6 +64864,17 @@ async function getLearnCardNetworkPlugin(learnCard, url3, apiToken) {
           boost.credentialSubject.id = targetProfile.did;
         }
         if (boost?.type?.includes("BoostCredential")) boost.boostId = boostUri;
+        if (typeof options === "object" && options.templateData && Object.keys(options.templateData).length > 0) {
+          try {
+            const boostString = JSON.stringify(boost);
+            const rendered = renderTemplateJson(boostString, options.templateData);
+            boost = JSON.parse(rendered);
+          } catch (error91) {
+            throw new Error(
+              `Template substitution failed: ${error91 instanceof Error ? error91.message : "Unknown error"}. Please check your templateData variables and ensure the rendered output is valid JSON.`
+            );
+          }
+        }
         if (typeof options === "object" && options.overideFn) {
           boost = options.overideFn(boost);
         }
@@ -64459,6 +64960,20 @@ async function getLearnCardNetworkPlugin(learnCard, url3, apiToken) {
                 targetDid = targetProfile.did;
               }
               let boost = data.data;
+              if (input.templateData && Object.keys(input.templateData).length > 0) {
+                try {
+                  const boostString = JSON.stringify(boost);
+                  const rendered = renderTemplateJson(
+                    boostString,
+                    input.templateData
+                  );
+                  boost = JSON.parse(rendered);
+                } catch (error91) {
+                  throw new Error(
+                    `Failed to apply template data: ${error91 instanceof Error ? error91.message : "Unknown error"}`
+                  );
+                }
+              }
               if (isVC2Format(boost)) {
                 boost.validFrom = (/* @__PURE__ */ new Date()).toISOString();
               } else {
@@ -65130,4 +65645,12 @@ export {
 @trpc/client/dist/links/retryLink.mjs:
   (* istanbul ignore file -- @preserve *)
 */
+/*! Bundled license information:
+
+mustache/mustache.mjs:
+  (*!
+   * mustache.js - Logic-less {{mustache}} templates with JavaScript
+   * http://github.com/janl/mustache.js
+   *)
+*/
 //# sourceMappingURL=lcn-plugin.esm.js.map