@bedelightful/es6-template-strings 0.0.5

package/dist/lib/compile.js

@@ -0,0 +1,134 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var compile_exports = {};
+__export(compile_exports, {
+  default: () => compile
+});
+module.exports = __toCommonJS(compile_exports);
+var import_esniff = __toESM(require("esniff"), 1);
+var _a;
+let i;
+let current;
+let literals;
+let substitutions;
+let template;
+let Notation = "$";
+let NotationStart = "{";
+let NotationEnd = "}";
+let Compile = (_a = class {
+}, __name(_a, "Compile"), __publicField(_a, "sOut", /* @__PURE__ */ __name((char) => {
+  if (char === "\\")
+    return _a.sEscape;
+  if (char === Notation)
+    return _a.sAhead;
+  current += char;
+  return _a.sOut;
+}, "sOut")), __publicField(_a, "sEscape", /* @__PURE__ */ __name((char) => {
+  if (char !== "\\" && char !== Notation) {
+    current += "\\";
+  }
+  current += char;
+  return _a.sOut;
+}, "sEscape")), __publicField(_a, "sAhead", /* @__PURE__ */ __name((char) => {
+  if (char === NotationStart) {
+    literals == null ? void 0 : literals.push(current);
+    current = "";
+    return _a.sIn;
+  }
+  if (char === Notation) {
+    current += Notation;
+    return _a.sAhead;
+  }
+  current += Notation + char;
+  return _a.sOut;
+}, "sAhead")), __publicField(_a, "sIn", /* @__PURE__ */ __name(() => {
+  const code = template.slice(i);
+  let end;
+  (0, import_esniff.default)(code, NotationEnd, (j) => {
+    if (import_esniff.default.nest >= 0)
+      return import_esniff.default.next();
+    end = j;
+  });
+  if (end != null) {
+    substitutions == null ? void 0 : substitutions.push(template.slice(i, i + end));
+    i += end;
+    current = "";
+    return _a.sOut;
+  }
+  end = code.length;
+  i += end;
+  current += code;
+  return _a.sIn;
+}, "sIn")), __publicField(_a, "sInEscape", /* @__PURE__ */ __name(function(char) {
+  if (char !== "\\" && char !== NotationEnd) {
+    current += "\\";
+  }
+  current += char;
+  return _a.sIn;
+}, "sInEscape")), _a);
+function compile(str, options) {
+  current = "";
+  literals = [];
+  substitutions = [];
+  Notation = (options == null ? void 0 : options.notation) || "$";
+  NotationStart = (options == null ? void 0 : options.notationStart) || "{";
+  NotationEnd = (options == null ? void 0 : options.notationEnd) || "}";
+  template = String(str);
+  const { length } = template;
+  let state = Compile.sOut;
+  for (i = 0; i < length; i += 1) {
+    state = state(template[i]);
+  }
+  if (state === Compile.sOut) {
+    literals.push(current);
+  } else if (state === Compile.sEscape) {
+    literals.push(`${current}\\`);
+  } else if (state === Compile.sAhead) {
+    literals.push(current + Notation);
+  } else if (state === Compile.sIn) {
+    literals[literals.length - 1] += `${Notation}${NotationStart}${current}`;
+  } else if (state === Compile.sInEscape) {
+    literals[literals.length - 1] += `${Notation}${NotationStart}${current}\\`;
+  }
+  const result = {
+    literals,
+    substitutions
+  };
+  literals = null;
+  substitutions = null;
+  return result;
+}
+__name(compile, "compile");
+//# sourceMappingURL=compile.js.map

package/dist/lib/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/compile.ts"],"sourcesContent":["import esniff from \"esniff\"\nimport type { CompileOptions } from \"./types\"\n\nlet i: number\nlet current: string\nlet literals: null | Array<string>\nlet substitutions: null | Array<string>\nlet template: string\n\n/** Prefix for template syntax */\nlet Notation: string = \"$\"\n/** Opening delimiter for template syntax */\nlet NotationStart: string = \"{\"\n/** Closing delimiter for template syntax */\nlet NotationEnd: string = \"}\"\n\nexport interface Result {\n\tliterals: string[]\n\tsubstitutions: string[]\n}\n\ntype State = (char: string) => State\n\nclass Compile {\n\tstatic sOut: State = (char) => {\n\t\tif (char === \"\\\\\") return Compile.sEscape\n\t\tif (char === Notation) return Compile.sAhead\n\t\tcurrent += char\n\t\treturn Compile.sOut\n\t}\n\n\tstatic sEscape: State = (char) => {\n\t\tif (char !== \"\\\\\" && char !== Notation) {\n\t\t\tcurrent += \"\\\\\"\n\t\t}\n\t\tcurrent += char\n\t\treturn Compile.sOut\n\t}\n\n\tstatic sAhead: State = (char) => {\n\t\tif (char === NotationStart) {\n\t\t\tliterals?.push(current)\n\t\t\tcurrent = \"\"\n\t\t\treturn Compile.sIn\n\t\t}\n\t\tif (char === Notation) {\n\t\t\tcurrent += Notation\n\t\t\treturn Compile.sAhead\n\t\t}\n\t\tcurrent += Notation + char\n\t\treturn Compile.sOut\n\t}\n\n\tstatic sIn: State = () => {\n\t\tconst code = template.slice(i)\n\t\tlet end\n\n\t\t// eslint-disable-next-line consistent-return\n\t\tesniff(code, NotationEnd, (j: number) => {\n\t\t\tif (esniff.nest >= 0) return esniff.next()\n\t\t\tend = j\n\t\t})\n\t\tif (end != null) {\n\t\t\tsubstitutions?.push(template.slice(i, i + end))\n\t\t\ti += end\n\t\t\tcurrent = \"\"\n\t\t\treturn Compile.sOut\n\t\t}\n\t\tend = code.length\n\t\ti += end\n\t\tcurrent += code\n\t\treturn Compile.sIn\n\t}\n\n\tstatic sInEscape: State = function (char) {\n\t\tif (char !== \"\\\\\" && char !== NotationEnd) {\n\t\t\tcurrent += \"\\\\\"\n\t\t}\n\t\tcurrent += char\n\t\treturn Compile.sIn\n\t}\n}\n\nexport default function compile(str: string, options?: CompileOptions): Result {\n\tcurrent = \"\"\n\tliterals = []\n\tsubstitutions = []\n\n\tNotation = options?.notation || \"$\"\n\tNotationStart = options?.notationStart || \"{\"\n\tNotationEnd = options?.notationEnd || \"}\"\n\n\ttemplate = String(str)\n\tconst { length } = template\n\n\tlet state: State = Compile.sOut\n\tfor (i = 0; i < length; i += 1) {\n\t\tstate = state(template[i])\n\t}\n\tif (state === Compile.sOut) {\n\t\tliterals.push(current)\n\t} else if (state === Compile.sEscape) {\n\t\tliterals.push(`${current}\\\\`)\n\t} else if (state === Compile.sAhead) {\n\t\tliterals.push(current + Notation)\n\t} else if (state === Compile.sIn) {\n\t\tliterals[literals.length - 1] += `${Notation}${NotationStart}${current}`\n\t} else if (state === Compile.sInEscape) {\n\t\tliterals[literals.length - 1] += `${Notation}${NotationStart}${current}\\\\`\n\t}\n\n\tconst result: Result = { literals, substitutions }\n\tliterals = null\n\tsubstitutions = null\n\treturn result\n}\n"],"mappings":"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","names":["i","current","literals","substitutions","template","Notation","NotationStart","NotationEnd","Compile","sOut","char","sEscape","sAhead","push","sIn","code","slice","end","esniff","j","nest","next","length","sInEscape","str","options","notation","notationStart","notationEnd","String","state","result","compile"]}

package/dist/lib/index.d.cts

@@ -0,0 +1,22 @@
+/** Parser options */
+interface CompileOptions {
+    /** Prefix for template syntax */
+    notation?: string;
+    /** Opening delimiter for template syntax */
+    notationStart?: string;
+    /** Closing delimiter for template syntax */
+    notationEnd?: string;
+}
+interface ResolveOptions {
+    /** Skip failed expressions; otherwise return undefined for failures */
+    partial?: boolean;
+}
+/** Template parsing options */
+interface TemplateOptions extends CompileOptions, ResolveOptions {
+}
+
+declare function toArray(template: string, context: Record<string, any>, options?: TemplateOptions): string[];
+
+declare function export_default(template: string, context: Record<string, any>, options?: TemplateOptions): string;
+
+export { export_default as default, toArray as resolveToArray, export_default as resolveToString };

package/dist/lib/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default,
+  resolveToArray: () => import_to_array.default,
+  resolveToString: () => import_to_string.default
+});
+module.exports = __toCommonJS(src_exports);
+var import_to_array = __toESM(require("./to-array"), 1);
+var import_to_string = __toESM(require("./to-string"), 1);
+var src_default = import_to_string.default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveToArray,
+  resolveToString
+});
+//# sourceMappingURL=index.js.map

package/dist/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import resolveToArray from \"./to-array\"\nimport resolveToString from \"./to-string\"\n\nexport { resolveToString, resolveToArray }\nexport default resolveToString\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;wCAAAA;EAAA,wCAAAC;;AAAA;sBAA2B;AAC3B,uBAA4B;AAG5B,IAAA,cAAeA,iBAAAA;","names":["resolveToArray","resolveToString"]}

package/dist/lib/passthru-array.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var passthru_array_exports = {};
+__export(passthru_array_exports, {
+  default: () => passthru_array_default
+});
+module.exports = __toCommonJS(passthru_array_exports);
+var passthru_array_default = /* @__PURE__ */ __name((literals, ...substitutions) => {
+  const result = [];
+  const l = literals.length;
+  if (!l) {
+    return result;
+  }
+  result.push(literals[0]);
+  for (let i = 1; i < l; i += 1) {
+    result.push(arguments[i], literals[i]);
+  }
+  return result;
+}, "default");
+//# sourceMappingURL=passthru-array.js.map

package/dist/lib/passthru-array.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/passthru-array.ts"],"sourcesContent":["// @ts-ignore\nexport default (literals: Array<string>, ...substitutions: Array<string>): Array<string> => {\n\tconst result: Array<string> = []\n\tconst l = literals.length\n\tif (!l) {\n\t\treturn result\n\t}\n\tresult.push(literals[0])\n\tfor (let i = 1; i < l; i += 1) {\n\t\t// @ts-ignore\n\t\tresult.push(arguments[i], literals[i])\n\t}\n\treturn result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;;;;;AACA,IAAA,yBAAe,wBAACA,aAA4BC,kBAAAA;AAC3C,QAAMC,SAAwB,CAAA;AAC9B,QAAMC,IAAIH,SAASI;AACnB,MAAI,CAACD,GAAG;AACP,WAAOD;EACR;AACAA,SAAOG,KAAKL,SAAS,CAAA,CAAE;AACvB,WAASM,IAAI,GAAGA,IAAIH,GAAGG,KAAK,GAAG;AAE9BJ,WAAOG,KAAKE,UAAUD,CAAAA,GAAIN,SAASM,CAAAA,CAAE;EACtC;AACA,SAAOJ;AACR,GAZe;","names":["literals","substitutions","result","l","length","push","i","arguments"]}

package/dist/lib/passthru.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var passthru_exports = {};
+__export(passthru_exports, {
+  default: () => passthru_default
+});
+module.exports = __toCommonJS(passthru_exports);
+function passthru_default(literals, ..._substitutions) {
+  const args = arguments;
+  return literals.reduce((a, b, i) => {
+    return a + (args[i] === void 0 ? "" : String(args[i])) + b;
+  });
+}
+__name(passthru_default, "default");
+//# sourceMappingURL=passthru.js.map

package/dist/lib/passthru.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/passthru.ts"],"sourcesContent":["export default function (literals: Array<string>, ..._substitutions: Array<string>) {\n\t// eslint-disable-next-line prefer-rest-params\n\tconst args = arguments\n\treturn literals.reduce((a: string, b: string, i: number): string => {\n\t\treturn a + (args[i] === undefined ? \"\" : String(args[i])) + b\n\t})\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;;;;;AAAe,SAAf,iBAAyBA,aAA4BC,gBAA6B;AAEjF,QAAMC,OAAOC;AACb,SAAOH,SAASI,OAAO,CAACC,GAAWC,GAAWC,MAAAA;AAC7C,WAAOF,KAAKH,KAAKK,CAAAA,MAAOC,SAAY,KAAKC,OAAOP,KAAKK,CAAAA,CAAE,KAAKD;EAC7D,CAAA;AACD;AANA;","names":["literals","_substitutions","args","arguments","reduce","a","b","i","undefined","String"]}

package/dist/lib/resolve-to-array.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolve_to_array_exports = {};
+__export(resolve_to_array_exports, {
+  default: () => resolve_to_array_default
+});
+module.exports = __toCommonJS(resolve_to_array_exports);
+var import_resolve = __toESM(require("./resolve"), 1);
+var import_passthru_array = __toESM(require("./passthru-array"), 1);
+var resolve_to_array_default = /* @__PURE__ */ __name((data, context, options) => {
+  const [literals, ...result] = (0, import_resolve.default)(data, context, options);
+  return import_passthru_array.default.call(null, literals, ...result);
+}, "default");
+//# sourceMappingURL=resolve-to-array.js.map

package/dist/lib/resolve-to-array.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/resolve-to-array.ts"],"sourcesContent":["import resolve from \"./resolve\"\nimport passthru from \"./passthru-array\"\nimport type { Result } from \"./compile\"\nimport type { ResolveOptions } from \"./types\"\n\nexport default (data: Result, context: Record<string, any>, options?: ResolveOptions) => {\n\tconst [literals, ...result] = resolve(data, context, options)\n\treturn passthru.call(null, literals as Array<string>, ...(result as Array<string>))\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAAA,qBAAoB;AACpB,4BAAqB;AAIrB,IAAA,2BAAe,wBAACA,MAAcC,SAA8BC,YAAAA;AAC3D,QAAM,CAACC,UAAU,GAAGC,MAAAA,QAAUC,eAAAA,SAAQL,MAAMC,SAASC,OAAAA;AACrD,SAAOI,sBAAAA,QAASC,KAAK,MAAMJ,UAAAA,GAA+BC,MAAAA;AAC3D,GAHe;","names":["data","context","options","literals","result","resolve","passthru","call"]}

package/dist/lib/resolve-to-string.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolve_to_string_exports = {};
+__export(resolve_to_string_exports, {
+  default: () => resolve_to_string_default
+});
+module.exports = __toCommonJS(resolve_to_string_exports);
+var import_resolve = __toESM(require("./resolve"), 1);
+var import_passthru = __toESM(require("./passthru"), 1);
+var resolve_to_string_default = /* @__PURE__ */ __name((data, context, options) => {
+  const [literals, ...result] = (0, import_resolve.default)(data, context, options);
+  return import_passthru.default.call(null, literals, ...result);
+}, "default");
+//# sourceMappingURL=resolve-to-string.js.map

package/dist/lib/resolve-to-string.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/resolve-to-string.ts"],"sourcesContent":["import resolve from \"./resolve\"\nimport passthru from \"./passthru\"\nimport type { Result } from \"./compile\"\nimport type { ResolveOptions } from \"./types\"\n\nexport default (data: Result, context: Record<string, any>, options?: ResolveOptions) => {\n\tconst [literals, ...result] = resolve(data, context, options)\n\treturn passthru.call(null, literals as Array<string>, ...(result as Array<string>))\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAAA,qBAAoB;AACpB,sBAAqB;AAIrB,IAAA,4BAAe,wBAACA,MAAcC,SAA8BC,YAAAA;AAC3D,QAAM,CAACC,UAAU,GAAGC,MAAAA,QAAUC,eAAAA,SAAQL,MAAMC,SAASC,OAAAA;AACrD,SAAOI,gBAAAA,QAASC,KAAK,MAAMJ,UAAAA,GAA+BC,MAAAA;AAC3D,GAHe;","names":["data","context","options","literals","result","resolve","passthru","call"]}

package/dist/lib/resolve.js

@@ -0,0 +1,91 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolve_exports = {};
+__export(resolve_exports, {
+  default: () => processData
+});
+module.exports = __toCommonJS(resolve_exports);
+var import_is_var_name_valid = __toESM(require("esniff/is-var-name-valid"), 1);
+const { stringify } = JSON;
+function isValue(value) {
+  if (value === null || value === void 0)
+    throw new TypeError("Cannot use null or undefined");
+  return value;
+}
+__name(isValue, "isValue");
+function process(src, obj) {
+  for (const key in src) {
+    obj[key] = src[key];
+  }
+}
+__name(process, "process");
+function normalize(...args) {
+  const result = /* @__PURE__ */ Object.create(null);
+  args.forEach(function(options) {
+    if (!isValue(options))
+      return;
+    process(Object(options), result);
+  });
+  return result;
+}
+__name(normalize, "normalize");
+function processData(data, context, options = {}) {
+  isValue(data) && isValue(data == null ? void 0 : data.literals) && isValue(data == null ? void 0 : data.substitutions);
+  context = normalize(context);
+  const names = Object.keys(context).filter(import_is_var_name_valid.default);
+  const argNames = names.join(", ");
+  const argValues = names.map((name) => context[name]);
+  const { substitutions = [], literals = [] } = data;
+  return [
+    literals
+  ].concat(substitutions.map((expr) => {
+    let resolver;
+    if (!expr)
+      return void 0;
+    try {
+      resolver = new Function(argNames, `return (${expr})`);
+    } catch (error) {
+      throw new TypeError(`Unable to compile expression:
+	args: ${stringify(argNames)}
+	body: ${stringify(expr)}
+	error: ${error.stack}`);
+    }
+    try {
+      return resolver.apply(null, argValues);
+    } catch (e) {
+      if (options.partial) {
+        return `\${${expr}}`;
+      }
+      return "undefined";
+    }
+  }));
+}
+__name(processData, "processData");
+//# sourceMappingURL=resolve.js.map

package/dist/lib/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/resolve.ts"],"sourcesContent":["import isVarNameValid from \"esniff/is-var-name-valid\"\nimport type { Result } from \"./compile\"\nimport type { ResolveOptions } from \"./types\"\n\nconst { stringify } = JSON\n\nfunction isValue(value: any): any | never {\n\tif (value === null || value === undefined) throw new TypeError(\"Cannot use null or undefined\")\n\treturn value\n}\n\nfunction process(src: Record<string, any>, obj: Record<string, any>) {\n\t// eslint-disable-next-line guard-for-in,no-restricted-syntax\n\tfor (const key in src) {\n\t\tobj[key] = src[key]\n\t}\n}\n\nfunction normalize(...args: Array<any>) {\n\tconst result: Record<string, any> = Object.create(null)\n\targs.forEach(function (options) {\n\t\tif (!isValue(options)) return\n\t\tprocess(Object(options), result)\n\t})\n\treturn result\n}\n\nexport default function processData(\n\tdata: Result,\n\tcontext: Record<string, any>,\n\toptions: ResolveOptions = {},\n): Array<Array<string> | string> {\n\tisValue(data) && isValue(data?.literals) && isValue(data?.substitutions)\n\tcontext = normalize(context)\n\tconst names = Object.keys(context).filter(isVarNameValid)\n\tconst argNames = names.join(\", \")\n\tconst argValues = names.map((name: string) => context[name])\n\tconst { substitutions = [], literals = [] } = data\n\n\t// For failed expressions, return ${} only when options.partial is true; otherwise return undefined\n\treturn [literals].concat(\n\t\tsubstitutions.map((expr: string) => {\n\t\t\tlet resolver: Function\n\t\t\tif (!expr) return undefined\n\t\t\ttry {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-implied-eval\n\t\t\t\tresolver = new Function(argNames, `return (${expr})`)\n\t\t\t} catch (error: any) {\n\t\t\t\tthrow new TypeError(\n\t\t\t\t\t`Unable to compile expression:\\n\\targs: ${stringify(argNames)}\\n\\tbody: ${stringify(\n\t\t\t\t\t\texpr,\n\t\t\t\t\t)}\\n\\terror: ${error.stack}`,\n\t\t\t\t)\n\t\t\t}\n\t\t\ttry {\n\t\t\t\t// eslint-disable-next-line prefer-spread\n\t\t\t\treturn resolver.apply(null, argValues)\n\t\t\t} catch (e) {\n\t\t\t\tif (options.partial) {\n\t\t\t\t\treturn `\\${${expr}}`\n\t\t\t\t}\n\t\t\t\treturn \"undefined\"\n\n\t\t\t\t// Error handling intentionally suppressed for now; returns undefined instead\n\t\t\t\t// throw new TypeError(\n\t\t\t\t// \t`Unable to resolve expression:\\n\\targs: ${ stringify(argNames) }\\n\\tbody: ${ stringify(\n\t\t\t\t// \t\texpr\n\t\t\t\t// \t) }\\n\\terror: ${ e.stack }`\n\t\t\t\t// )\n\t\t\t}\n\t\t}),\n\t)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAAA,+BAA2B;AAI3B,MAAM,EAAEA,UAAS,IAAKC;AAEtB,SAASC,QAAQC,OAAU;AAC1B,MAAIA,UAAU,QAAQA,UAAUC;AAAW,UAAM,IAAIC,UAAU,8BAAA;AAC/D,SAAOF;AACR;AAHSD;AAKT,SAASI,QAAQC,KAA0BC,KAAwB;AAElE,aAAWC,OAAOF,KAAK;AACtBC,QAAIC,GAAAA,IAAOF,IAAIE,GAAAA;EAChB;AACD;AALSH;AAOT,SAASI,aAAaC,MAAgB;AACrC,QAAMC,SAA8BC,uBAAOC,OAAO,IAAA;AAClDH,OAAKI,QAAQ,SAAUC,SAAO;AAC7B,QAAI,CAACd,QAAQc,OAAAA;AAAU;AACvBV,YAAQO,OAAOG,OAAAA,GAAUJ,MAAAA;EAC1B,CAAA;AACA,SAAOA;AACR;AAPSF;AASM,SAAf,YACCO,MACAC,SACAF,UAA0B,CAAC,GAAC;AAE5Bd,UAAQe,IAAAA,KAASf,QAAQe,6BAAME,QAAAA,KAAajB,QAAQe,6BAAMG,aAAAA;AAC1DF,YAAUR,UAAUQ,OAAAA;AACpB,QAAMG,QAAQR,OAAOS,KAAKJ,OAAAA,EAASK,OAAOC,yBAAAA,OAAAA;AAC1C,QAAMC,WAAWJ,MAAMK,KAAK,IAAA;AAC5B,QAAMC,YAAYN,MAAMO,IAAI,CAACC,SAAiBX,QAAQW,IAAAA,CAAK;AAC3D,QAAM,EAAET,gBAAgB,CAAA,GAAID,WAAW,CAAA,EAAE,IAAKF;AAG9C,SAAO;IAACE;IAAUW,OACjBV,cAAcQ,IAAI,CAACG,SAAAA;AAClB,QAAIC;AACJ,QAAI,CAACD;AAAM,aAAO3B;AAClB,QAAI;AAEH4B,iBAAW,IAAIC,SAASR,UAAU,WAAWM,IAAAA,GAAO;IACrD,SAASG,OAAY;AACpB,YAAM,IAAI7B,UACT;SAA0CL,UAAUyB,QAAAA,CAAAA;SAAsBzB,UACzE+B,IAAAA,CAAAA;UACcG,MAAMC,KAAK,EAAE;IAE9B;AACA,QAAI;AAEH,aAAOH,SAASI,MAAM,MAAMT,SAAAA;IAC7B,SAASU,GAAG;AACX,UAAIrB,QAAQsB,SAAS;AACpB,eAAO,MAAMP,IAAAA;MACd;AACA,aAAO;IAQR;EACD,CAAA,CAAA;AAEF;AA7CwBQ;","names":["stringify","JSON","isValue","value","undefined","TypeError","process","src","obj","key","normalize","args","result","Object","create","forEach","options","data","context","literals","substitutions","names","keys","filter","isVarNameValid","argNames","join","argValues","map","name","concat","expr","resolver","Function","error","stack","apply","e","partial","processData"]}

package/dist/lib/to-array.js

@@ -0,0 +1,45 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var to_array_exports = {};
+__export(to_array_exports, {
+  default: () => toArray
+});
+module.exports = __toCommonJS(to_array_exports);
+var import_lodash_es = require("lodash-es");
+var import_compile = __toESM(require("./compile"), 1);
+var import_resolve_to_array = __toESM(require("./resolve-to-array"), 1);
+function toArray(template, context, options) {
+  const compileOptions = (0, import_lodash_es.omit)(options, "partial");
+  return (0, import_resolve_to_array.default)((0, import_compile.default)(template, compileOptions), context, {
+    partial: options == null ? void 0 : options.partial
+  });
+}
+__name(toArray, "toArray");
+//# sourceMappingURL=to-array.js.map

package/dist/lib/to-array.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/to-array.ts"],"sourcesContent":["import { omit } from \"lodash-es\"\nimport compile from \"./compile\"\nimport resolve from \"./resolve-to-array\"\nimport type { CompileOptions, TemplateOptions } from \"./types\"\n\nexport default function toArray(\n\ttemplate: string,\n\tcontext: Record<string, any>,\n\toptions?: TemplateOptions,\n) {\n\tconst compileOptions: CompileOptions = omit(options, \"partial\")\n\treturn resolve(compile(template, compileOptions), context, { partial: options?.partial })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAAA,uBAAqB;AACrB,qBAAoB;AACpB,8BAAoB;AAGL,SAAf,QACCA,UACAC,SACAC,SAAyB;AAEzB,QAAMC,qBAAiCC,uBAAKF,SAAS,SAAA;AACrD,aAAOG,wBAAAA,aAAQC,eAAAA,SAAQN,UAAUG,cAAAA,GAAiBF,SAAS;IAAEM,SAASL,mCAASK;EAAQ,CAAA;AACxF;AAPwBC;","names":["template","context","options","compileOptions","omit","resolve","compile","partial","toArray"]}

package/dist/lib/to-string.js

@@ -0,0 +1,45 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var to_string_exports = {};
+__export(to_string_exports, {
+  default: () => to_string_default
+});
+module.exports = __toCommonJS(to_string_exports);
+var import_lodash_es = require("lodash-es");
+var import_compile = __toESM(require("./compile"), 1);
+var import_resolve_to_string = __toESM(require("./resolve-to-string"), 1);
+function to_string_default(template, context, options) {
+  const compileOptions = (0, import_lodash_es.omit)(options, "partial");
+  return (0, import_resolve_to_string.default)((0, import_compile.default)(template, compileOptions), context, {
+    partial: options == null ? void 0 : options.partial
+  });
+}
+__name(to_string_default, "default");
+//# sourceMappingURL=to-string.js.map

package/dist/lib/to-string.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/to-string.ts"],"sourcesContent":["import { omit } from \"lodash-es\"\nimport compile from \"./compile\"\nimport resolve from \"./resolve-to-string\"\nimport type { CompileOptions, TemplateOptions } from \"./types\"\n\nexport default function (\n\ttemplate: string,\n\tcontext: Record<string, any>,\n\toptions?: TemplateOptions,\n) {\n\tconst compileOptions: CompileOptions = omit(options, \"partial\")\n\treturn resolve(compile(template, compileOptions), context, { partial: options?.partial })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAAA,uBAAqB;AACrB,qBAAoB;AACpB,+BAAoB;AAGL,SAAf,kBACCA,UACAC,SACAC,SAAyB;AAEzB,QAAMC,qBAAiCC,uBAAKF,SAAS,SAAA;AACrD,aAAOG,yBAAAA,aAAQC,eAAAA,SAAQN,UAAUG,cAAAA,GAAiBF,SAAS;IAAEM,SAASL,mCAASK;EAAQ,CAAA;AACxF;AAPA;","names":["template","context","options","compileOptions","omit","resolve","compile","partial"]}

package/dist/lib/types.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types.ts"],"sourcesContent":["/** Parser options */\nexport interface CompileOptions {\n\t/** Prefix for template syntax */\n\tnotation?: string\n\t/** Opening delimiter for template syntax */\n\tnotationStart?: string\n\t/** Closing delimiter for template syntax */\n\tnotationEnd?: string\n}\n\nexport interface ResolveOptions {\n\t/** Skip failed expressions; otherwise return undefined for failures */\n\tpartial?: boolean\n}\n\n/** Template parsing options */\nexport interface TemplateOptions extends CompileOptions, ResolveOptions {}\n"],"mappings":";;;;;;;;;;;;;;AAAA;;","names":[]}