@noormdev/sdk 1.0.0-alpha.9 → 1.0.0

package/dist/chunk-DSXHOXDE.js

@@ -0,0 +1,2591 @@
+import { createRequire } from 'module';
+import { attemptSync, observer, attempt } from './chunk-QAECL4RN.js';
+import { dist_default } from './chunk-TBRUDUBQ.js';
+import { readFile as readFile$1, readdir, stat } from 'fs/promises';
+import * as fs from 'fs';
+import { readFileSync, createReadStream, unlinkSync } from 'fs';
+import * as path from 'path';
+import path__default, { dirname, join } from 'path';
+import { pathToFileURL } from 'url';
+import { randomBytes, pbkdf2Sync, createCipheriv, createDecipheriv } from 'crypto';
+import { gunzipSync, createGunzip } from 'zlib';
+import { createInterface } from 'readline';
+import { PassThrough, Transform } from 'stream';
+
+createRequire(import.meta.url);
+var EtaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Eta Error";
+  }
+};
+var EtaParseError = class extends EtaError {
+  constructor(message) {
+    super(message);
+    this.name = "EtaParser Error";
+  }
+};
+var EtaRuntimeError = class extends EtaError {
+  constructor(message) {
+    super(message);
+    this.name = "EtaRuntime Error";
+  }
+};
+var EtaFileResolutionError = class extends EtaError {
+  constructor(message) {
+    super(message);
+    this.name = "EtaFileResolution Error";
+  }
+};
+var EtaNameResolutionError = class extends EtaError {
+  constructor(message) {
+    super(message);
+    this.name = "EtaNameResolution Error";
+  }
+};
+function ParseErr(message, str, indx) {
+  const whitespace2 = str.slice(0, indx).split(/\n/);
+  const lineNo = whitespace2.length;
+  const colNo = whitespace2[lineNo - 1].length + 1;
+  message += " at line " + lineNo + " col " + colNo + ":\n\n  " + str.split(/\n/)[lineNo - 1] + "\n  " + Array(colNo).join(" ") + "^";
+  throw new EtaParseError(message);
+}
+function RuntimeErr(originalError, str, lineNo, path$1) {
+  const lines = str.split("\n");
+  const start = Math.max(lineNo - 3, 0);
+  const end = Math.min(lines.length, lineNo + 3);
+  const filename = path$1;
+  const context = lines.slice(start, end).map((line, i) => {
+    const curr = i + start + 1;
+    return (curr === lineNo ? " >> " : "    ") + curr + "| " + line;
+  }).join("\n");
+  const err = new EtaRuntimeError((filename ? filename + ":" + lineNo + "\n" : "line " + lineNo + "\n") + context + "\n\n" + originalError.message);
+  err.name = originalError.name;
+  err.cause = originalError;
+  throw err;
+}
+function readFile(path$1) {
+  let res = "";
+  try {
+    res = fs.readFileSync(path$1, "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") throw new EtaFileResolutionError(`Could not find template: ${path$1}`);
+    else throw err;
+  }
+  return res;
+}
+function resolvePath(templatePath, options) {
+  let resolvedFilePath = "";
+  const views = this.config.views;
+  if (!views) throw new EtaFileResolutionError("Views directory is not defined");
+  const baseFilePath = options?.filepath;
+  const defaultExtension = this.config.defaultExtension === void 0 ? ".eta" : this.config.defaultExtension;
+  const cacheIndex = JSON.stringify({
+    filename: baseFilePath,
+    path: templatePath,
+    views: this.config.views
+  });
+  templatePath += path.extname(templatePath) ? "" : defaultExtension;
+  if (baseFilePath) {
+    if (this.config.cacheFilepaths && this.filepathCache[cacheIndex]) return this.filepathCache[cacheIndex];
+    if (absolutePathRegExp.exec(templatePath)?.length) {
+      const formattedPath = templatePath.replace(/^\/*|^\\*/, "");
+      resolvedFilePath = path.join(views, formattedPath);
+    } else resolvedFilePath = path.join(path.dirname(baseFilePath), templatePath);
+  } else resolvedFilePath = path.join(views, templatePath);
+  if (dirIsChild(views, resolvedFilePath)) {
+    if (baseFilePath && this.config.cacheFilepaths) this.filepathCache[cacheIndex] = resolvedFilePath;
+    return resolvedFilePath;
+  } else throw new EtaFileResolutionError(`Template '${templatePath}' is not in the views directory`);
+}
+function dirIsChild(parent, dir) {
+  const relative2 = path.relative(parent, dir);
+  return relative2 && !relative2.startsWith("..") && !path.isAbsolute(relative2);
+}
+var absolutePathRegExp = /^\\|^\//;
+var AsyncFunction = (async () => {
+}).constructor;
+function compile(str, options) {
+  const config = this.config;
+  const ctor = options?.async ? AsyncFunction : Function;
+  try {
+    return new ctor(config.varName, "options", this.compileToString.call(this, str, options));
+  } catch (e) {
+    if (e instanceof SyntaxError) throw new EtaParseError("Bad template syntax\n\n" + e.message + "\n" + Array(e.message.length + 1).join("=") + "\n" + this.compileToString.call(this, str, options) + "\n");
+    else throw e;
+  }
+}
+function compileToString(str, options) {
+  const config = this.config;
+  const isAsync = options?.async;
+  const compileBody$1 = this.compileBody;
+  const buffer = this.parse.call(this, str);
+  let res = `${config.functionHeader}
+let include = (__eta_t, __eta_d) => this.render(__eta_t, {...${config.varName}, ...(__eta_d ?? {})}, options);
+let includeAsync = (__eta_t, __eta_d) => this.renderAsync(__eta_t, {...${config.varName}, ...(__eta_d ?? {})}, options);
+
+let __eta = {res: "", e: this.config.escapeFunction, f: this.config.filterFunction${config.debug ? ', line: 1, templateStr: "' + str.replace(/\\|"/g, "\\$&").replace(/\r\n|\n|\r/g, "\\n") + '"' : ""}};
+
+function layout(path, data) {
+  __eta.layout = path;
+  __eta.layoutData = data;
+}${config.debug ? "try {" : ""}${config.useWith ? "with(" + config.varName + "||{}){" : ""}
+
+function ${config.outputFunctionName}(s){__eta.res+=s;}
+
+${compileBody$1.call(this, buffer)}
+if (__eta.layout) {
+  __eta.res = ${isAsync ? "await includeAsync" : "include"} (__eta.layout, {...${config.varName}, body: __eta.res, ...__eta.layoutData});
+}
+${config.useWith ? "}" : ""}${config.debug ? "} catch (e) { this.RuntimeErr(e, __eta.templateStr, __eta.line, options.filepath) }" : ""}
+return __eta.res;
+`;
+  if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+    const plugin = config.plugins[i];
+    if (plugin.processFnString) res = plugin.processFnString(res, config);
+  }
+  return res;
+}
+function compileBody(buff) {
+  const config = this.config;
+  let i = 0;
+  const buffLength = buff.length;
+  let returnStr = "";
+  for (; i < buffLength; i++) {
+    const currentBlock = buff[i];
+    if (typeof currentBlock === "string") returnStr += "__eta.res+='" + currentBlock + "';\n";
+    else {
+      const type = currentBlock.t;
+      let content = currentBlock.val || "";
+      if (config.debug) returnStr += "__eta.line=" + currentBlock.lineNo + "\n";
+      if (type === "r") {
+        if (config.autoFilter) content = "__eta.f(" + content + ")";
+        returnStr += "__eta.res+=" + content + ";\n";
+      } else if (type === "i") {
+        if (config.autoFilter) content = "__eta.f(" + content + ")";
+        if (config.autoEscape) content = "__eta.e(" + content + ")";
+        returnStr += "__eta.res+=" + content + ";\n";
+      } else if (type === "e") returnStr += content + "\n";
+    }
+  }
+  return returnStr;
+}
+function trimWS(str, config, wsLeft, wsRight) {
+  let leftTrim;
+  let rightTrim;
+  if (Array.isArray(config.autoTrim)) {
+    leftTrim = config.autoTrim[1];
+    rightTrim = config.autoTrim[0];
+  } else leftTrim = rightTrim = config.autoTrim;
+  if (wsLeft || wsLeft === false) leftTrim = wsLeft;
+  if (wsRight || wsRight === false) rightTrim = wsRight;
+  if (!rightTrim && !leftTrim) return str;
+  if (leftTrim === "slurp" && rightTrim === "slurp") return str.trim();
+  if (leftTrim === "_" || leftTrim === "slurp") str = str.trimStart();
+  else if (leftTrim === "-" || leftTrim === "nl") str = str.replace(/^(?:\r\n|\n|\r)/, "");
+  if (rightTrim === "_" || rightTrim === "slurp") str = str.trimEnd();
+  else if (rightTrim === "-" || rightTrim === "nl") str = str.replace(/(?:\r\n|\n|\r)$/, "");
+  return str;
+}
+var escMap = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function replaceChar(s) {
+  return escMap[s];
+}
+function XMLEscape(str) {
+  const newStr = String(str);
+  if (/[&<>"']/.test(newStr)) return newStr.replace(/[&<>"']/g, replaceChar);
+  else return newStr;
+}
+var defaultConfig = {
+  autoEscape: true,
+  autoFilter: false,
+  autoTrim: [false, "nl"],
+  cache: false,
+  cacheFilepaths: true,
+  debug: false,
+  escapeFunction: XMLEscape,
+  filterFunction: (val) => String(val),
+  outputFunctionName: "output",
+  functionHeader: "",
+  parse: {
+    exec: "",
+    interpolate: "=",
+    raw: "~"
+  },
+  plugins: [],
+  rmWhitespace: false,
+  tags: ["<%", "%>"],
+  useWith: false,
+  varName: "it",
+  defaultExtension: ".eta"
+};
+var templateLitReg = /`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})*}|(?!\${)[^\\`])*`/g;
+var singleQuoteReg = /'(?:\\[\s\w"'\\`]|[^\n\r'\\])*?'/g;
+var doubleQuoteReg = /"(?:\\[\s\w"'\\`]|[^\n\r"\\])*?"/g;
+function escapeRegExp(string) {
+  return string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+}
+function getLineNo(str, index) {
+  return str.slice(0, index).split("\n").length;
+}
+function parse(str) {
+  const config = this.config;
+  let buffer = [];
+  let trimLeftOfNextStr = false;
+  let lastIndex = 0;
+  const parseOptions = config.parse;
+  if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+    const plugin = config.plugins[i];
+    if (plugin.processTemplate) str = plugin.processTemplate(str, config);
+  }
+  if (config.rmWhitespace) str = str.replace(/[\r\n]+/g, "\n").replace(/^\s+|\s+$/gm, "");
+  templateLitReg.lastIndex = 0;
+  singleQuoteReg.lastIndex = 0;
+  doubleQuoteReg.lastIndex = 0;
+  function pushString(strng, shouldTrimRightOfString) {
+    if (strng) {
+      strng = trimWS(strng, config, trimLeftOfNextStr, shouldTrimRightOfString);
+      if (strng) {
+        strng = strng.replace(/\\|'/g, "\\$&").replace(/\r\n|\n|\r/g, "\\n");
+        buffer.push(strng);
+      }
+    }
+  }
+  const prefixes = [
+    parseOptions.exec,
+    parseOptions.interpolate,
+    parseOptions.raw
+  ].reduce((accumulator, prefix) => {
+    if (accumulator && prefix) return accumulator + "|" + escapeRegExp(prefix);
+    else if (prefix) return escapeRegExp(prefix);
+    else return accumulator;
+  }, "");
+  const parseOpenReg = new RegExp(escapeRegExp(config.tags[0]) + "(-|_)?\\s*(" + prefixes + ")?\\s*", "g");
+  const parseCloseReg = new RegExp("'|\"|`|\\/\\*|(\\s*(-|_)?" + escapeRegExp(config.tags[1]) + ")", "g");
+  let m;
+  while (m = parseOpenReg.exec(str)) {
+    const precedingString = str.slice(lastIndex, m.index);
+    lastIndex = m[0].length + m.index;
+    const wsLeft = m[1];
+    const prefix = m[2] || "";
+    pushString(precedingString, wsLeft);
+    parseCloseReg.lastIndex = lastIndex;
+    let closeTag;
+    let currentObj = false;
+    while (closeTag = parseCloseReg.exec(str)) if (closeTag[1]) {
+      const content = str.slice(lastIndex, closeTag.index);
+      parseOpenReg.lastIndex = lastIndex = parseCloseReg.lastIndex;
+      trimLeftOfNextStr = closeTag[2];
+      currentObj = {
+        t: prefix === parseOptions.exec ? "e" : prefix === parseOptions.raw ? "r" : prefix === parseOptions.interpolate ? "i" : "",
+        val: content
+      };
+      break;
+    } else {
+      const char = closeTag[0];
+      if (char === "/*") {
+        const commentCloseInd = str.indexOf("*/", parseCloseReg.lastIndex);
+        if (commentCloseInd === -1) ParseErr("unclosed comment", str, closeTag.index);
+        parseCloseReg.lastIndex = commentCloseInd;
+      } else if (char === "'") {
+        singleQuoteReg.lastIndex = closeTag.index;
+        if (singleQuoteReg.exec(str)) parseCloseReg.lastIndex = singleQuoteReg.lastIndex;
+        else ParseErr("unclosed string", str, closeTag.index);
+      } else if (char === '"') {
+        doubleQuoteReg.lastIndex = closeTag.index;
+        if (doubleQuoteReg.exec(str)) parseCloseReg.lastIndex = doubleQuoteReg.lastIndex;
+        else ParseErr("unclosed string", str, closeTag.index);
+      } else if (char === "`") {
+        templateLitReg.lastIndex = closeTag.index;
+        if (templateLitReg.exec(str)) parseCloseReg.lastIndex = templateLitReg.lastIndex;
+        else ParseErr("unclosed string", str, closeTag.index);
+      }
+    }
+    if (currentObj) {
+      if (config.debug) currentObj.lineNo = getLineNo(str, m.index);
+      buffer.push(currentObj);
+    } else ParseErr("unclosed tag", str, m.index);
+  }
+  pushString(str.slice(lastIndex, str.length), false);
+  if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+    const plugin = config.plugins[i];
+    if (plugin.processAST) buffer = plugin.processAST(buffer, config);
+  }
+  return buffer;
+}
+function handleCache(template, options) {
+  const templateStore = options?.async ? this.templatesAsync : this.templatesSync;
+  if (this.resolvePath && this.readFile && !template.startsWith("@")) {
+    const templatePath = options.filepath;
+    const cachedTemplate = templateStore.get(templatePath);
+    if (this.config.cache && cachedTemplate) return cachedTemplate;
+    else {
+      const templateString = this.readFile(templatePath);
+      const templateFn = this.compile(templateString, options);
+      if (this.config.cache) templateStore.define(templatePath, templateFn);
+      return templateFn;
+    }
+  } else {
+    const cachedTemplate = templateStore.get(template);
+    if (cachedTemplate) return cachedTemplate;
+    else throw new EtaNameResolutionError(`Failed to get template '${template}'`);
+  }
+}
+function render(template, data, meta) {
+  let templateFn;
+  const options = {
+    ...meta,
+    async: false
+  };
+  if (typeof template === "string") {
+    if (this.resolvePath && this.readFile && !template.startsWith("@")) options.filepath = this.resolvePath(template, options);
+    templateFn = handleCache.call(this, template, options);
+  } else templateFn = template;
+  return templateFn.call(this, data, options);
+}
+function renderAsync(template, data, meta) {
+  let templateFn;
+  const options = {
+    ...meta,
+    async: true
+  };
+  if (typeof template === "string") {
+    if (this.resolvePath && this.readFile && !template.startsWith("@")) options.filepath = this.resolvePath(template, options);
+    templateFn = handleCache.call(this, template, options);
+  } else templateFn = template;
+  const res = templateFn.call(this, data, options);
+  return Promise.resolve(res);
+}
+function renderString(template, data) {
+  const templateFn = this.compile(template, { async: false });
+  return render.call(this, templateFn, data);
+}
+function renderStringAsync(template, data) {
+  const templateFn = this.compile(template, { async: true });
+  return renderAsync.call(this, templateFn, data);
+}
+var Cacher = class {
+  constructor(cache) {
+    this.cache = cache;
+  }
+  define(key, val) {
+    this.cache[key] = val;
+  }
+  get(key) {
+    return this.cache[key];
+  }
+  remove(key) {
+    delete this.cache[key];
+  }
+  reset() {
+    this.cache = {};
+  }
+  load(cacheObj) {
+    this.cache = {
+      ...this.cache,
+      ...cacheObj
+    };
+  }
+};
+var Eta$1 = class {
+  constructor(customConfig) {
+    if (customConfig) this.config = {
+      ...defaultConfig,
+      ...customConfig
+    };
+    else this.config = { ...defaultConfig };
+  }
+  config;
+  RuntimeErr = RuntimeErr;
+  compile = compile;
+  compileToString = compileToString;
+  compileBody = compileBody;
+  parse = parse;
+  render = render;
+  renderAsync = renderAsync;
+  renderString = renderString;
+  renderStringAsync = renderStringAsync;
+  filepathCache = {};
+  templatesSync = new Cacher({});
+  templatesAsync = new Cacher({});
+  resolvePath = null;
+  readFile = null;
+  configure(customConfig) {
+    this.config = {
+      ...this.config,
+      ...customConfig
+    };
+  }
+  withConfig(customConfig) {
+    return {
+      ...this,
+      config: {
+        ...this.config,
+        ...customConfig
+      }
+    };
+  }
+  loadTemplate(name, template, options) {
+    if (typeof template === "string") (options?.async ? this.templatesAsync : this.templatesSync).define(name, this.compile(template, options));
+    else {
+      let templates = this.templatesSync;
+      if (template.constructor.name === "AsyncFunction" || options?.async) templates = this.templatesAsync;
+      templates.define(name, template);
+    }
+  }
+};
+var Eta = class extends Eta$1 {
+  readFile = readFile;
+  resolvePath = resolvePath;
+};
+
+// src/core/template/types.ts
+var TEMPLATE_EXTENSION = ".tmpl";
+var HELPER_FILENAME = "$helpers";
+var HELPER_EXTENSIONS = [".ts", ".js", ".mjs"];
+
+// node_modules/voca/es/index.js
+function _extends() {
+  _extends = Object.assign || function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+    return arr2;
+  }
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _iterableToArray(iter) {
+  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}
+function _iterableToArrayLimit(arr, i) {
+  if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
+    return;
+  }
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = void 0;
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+  return _arr;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}
+function isNil(value) {
+  return value === void 0 || value === null;
+}
+function coerceToBoolean(value) {
+  var defaultValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+  if (isNil(value)) {
+    return defaultValue;
+  }
+  return Boolean(value);
+}
+function isString(subject) {
+  return typeof subject === "string";
+}
+function coerceToString(value) {
+  var defaultValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+  if (isNil(value)) {
+    return defaultValue;
+  }
+  if (isString(value)) {
+    return value;
+  }
+  return String(value);
+}
+function capitalize(subject, restToLower) {
+  var subjectString = coerceToString(subject);
+  var restToLowerCaseBoolean = coerceToBoolean(restToLower);
+  if (subjectString === "") {
+    return "";
+  }
+  if (restToLowerCaseBoolean) {
+    subjectString = subjectString.toLowerCase();
+  }
+  return subjectString.substr(0, 1).toUpperCase() + subjectString.substr(1);
+}
+function lowerCase(subject) {
+  var subjectString = coerceToString(subject, "");
+  return subjectString.toLowerCase();
+}
+var digit = "\\d";
+var whitespace = "\\s\\uFEFF\\xA0";
+var highSurrogate = "\\uD800-\\uDBFF";
+var lowSurrogate = "\\uDC00-\\uDFFF";
+var diacriticalMark = "\\u0300-\\u036F\\u1AB0-\\u1AFF\\u1DC0-\\u1DFF\\u20D0-\\u20FF\\uFE20-\\uFE2F";
+var base = "\\0-\\u02FF\\u0370-\\u1AAF\\u1B00-\\u1DBF\\u1E00-\\u20CF\\u2100-\\uD7FF\\uE000-\\uFE1F\\uFE30-\\uFFFF";
+var REGEXP_COMBINING_MARKS = new RegExp("([" + base + "]|[" + highSurrogate + "][" + lowSurrogate + "]|[" + highSurrogate + "](?![" + lowSurrogate + "])|(?:[^" + highSurrogate + "]|^)[" + lowSurrogate + "])([" + diacriticalMark + "]+)", "g");
+var REGEXP_SURROGATE_PAIRS = new RegExp("([" + highSurrogate + "])([" + lowSurrogate + "])", "g");
+var REGEXP_UNICODE_CHARACTER = new RegExp("((?:[" + base + "]|[" + highSurrogate + "][" + lowSurrogate + "]|[" + highSurrogate + "](?![" + lowSurrogate + "])|(?:[^" + highSurrogate + "]|^)[" + lowSurrogate + "])(?:[" + diacriticalMark + "]+))|([" + highSurrogate + "][" + lowSurrogate + "])|([\\n\\r\\u2028\\u2029])|(.)", "g");
+var REGEXP_WHITESPACE = new RegExp("[" + whitespace + "]");
+var REGEXP_TRIM_LEFT = new RegExp("^[" + whitespace + "]+");
+var REGEXP_TRIM_RIGHT = new RegExp("[" + whitespace + "]+$");
+var REGEXP_DIGIT = new RegExp("^" + digit + "+$");
+var REGEXP_SPECIAL_CHARACTERS = /[-[\]{}()*+!<=:?./\\^$|#,]/g;
+var REGEXP_NON_LATIN = /[^A-Za-z0-9]/g;
+var REGEXP_HTML_SPECIAL_CHARACTERS = /[<>&"'`]/g;
+var REGEXP_CONVERSION_SPECIFICATION = /(%{1,2})(?:(\d+)\$)?(\+)?([ 0]|'.{1})?(-)?(\d+)?(?:\.(\d+))?([bcdiouxXeEfgGs])?/g;
+var REGEXP_TRAILING_ZEROS = /\.?0+$/g;
+var REGEXP_TAG_LIST = /<([A-Za-z0-9]+)>/g;
+var generalPunctuationBlock = "\\u2000-\\u206F";
+var nonCharacter = "\\x00-\\x2F\\x3A-\\x40\\x5B-\\x60\\x7b-\\xBF\\xD7\\xF7";
+var dingbatBlock = "\\u2700-\\u27BF";
+var lowerCaseLetter = "a-z\\xB5\\xDF-\\xF6\\xF8-\\xFF\\u0101\\u0103\\u0105\\u0107\\u0109\\u010B\\u010D\\u010F\\u0111\\u0113\\u0115\\u0117\\u0119\\u011B\\u011D\\u011F\\u0121\\u0123\\u0125\\u0127\\u0129\\u012B\\u012D\\u012F\\u0131\\u0133\\u0135\\u0137\\u0138\\u013A\\u013C\\u013E\\u0140\\u0142\\u0144\\u0146\\u0148\\u0149\\u014B\\u014D\\u014F\\u0151\\u0153\\u0155\\u0157\\u0159\\u015B\\u015D\\u015F\\u0161\\u0163\\u0165\\u0167\\u0169\\u016B\\u016D\\u016F\\u0171\\u0173\\u0175\\u0177\\u017A\\u017C\\u017E-\\u0180\\u0183\\u0185\\u0188\\u018C\\u018D\\u0192\\u0195\\u0199-\\u019B\\u019E\\u01A1\\u01A3\\u01A5\\u01A8\\u01AA\\u01AB\\u01AD\\u01B0\\u01B4\\u01B6\\u01B9\\u01BA\\u01BD-\\u01BF\\u01C6\\u01C9\\u01CC\\u01CE\\u01D0\\u01D2\\u01D4\\u01D6\\u01D8\\u01DA\\u01DC\\u01DD\\u01DF\\u01E1\\u01E3\\u01E5\\u01E7\\u01E9\\u01EB\\u01ED\\u01EF\\u01F0\\u01F3\\u01F5\\u01F9\\u01FB\\u01FD\\u01FF\\u0201\\u0203\\u0205\\u0207\\u0209\\u020B\\u020D\\u020F\\u0211\\u0213\\u0215\\u0217\\u0219\\u021B\\u021D\\u021F\\u0221\\u0223\\u0225\\u0227\\u0229\\u022B\\u022D\\u022F\\u0231\\u0233-\\u0239\\u023C\\u023F\\u0240\\u0242\\u0247\\u0249\\u024B\\u024D\\u024F";
+var upperCaseLetter = "\\x41-\\x5a\\xc0-\\xd6\\xd8-\\xde\\u0100\\u0102\\u0104\\u0106\\u0108\\u010a\\u010c\\u010e\\u0110\\u0112\\u0114\\u0116\\u0118\\u011a\\u011c\\u011e\\u0120\\u0122\\u0124\\u0126\\u0128\\u012a\\u012c\\u012e\\u0130\\u0132\\u0134\\u0136\\u0139\\u013b\\u013d\\u013f\\u0141\\u0143\\u0145\\u0147\\u014a\\u014c\\u014e\\u0150\\u0152\\u0154\\u0156\\u0158\\u015a\\u015c\\u015e\\u0160\\u0162\\u0164\\u0166\\u0168\\u016a\\u016c\\u016e\\u0170\\u0172\\u0174\\u0176\\u0178\\u0179\\u017b\\u017d\\u0181\\u0182\\u0184\\u0186\\u0187\\u0189-\\u018b\\u018e-\\u0191\\u0193\\u0194\\u0196-\\u0198\\u019c\\u019d\\u019f\\u01a0\\u01a2\\u01a4\\u01a6\\u01a7\\u01a9\\u01ac\\u01ae\\u01af\\u01b1-\\u01b3\\u01b5\\u01b7\\u01b8\\u01bc\\u01c4\\u01c5\\u01c7\\u01c8\\u01ca\\u01cb\\u01cd\\u01cf\\u01d1\\u01d3\\u01d5\\u01d7\\u01d9\\u01db\\u01de\\u01e0\\u01e2\\u01e4\\u01e6\\u01e8\\u01ea\\u01ec\\u01ee\\u01f1\\u01f2\\u01f4\\u01f6-\\u01f8\\u01fa\\u01fc\\u01fe\\u0200\\u0202\\u0204\\u0206\\u0208\\u020a\\u020c\\u020e\\u0210\\u0212\\u0214\\u0216\\u0218\\u021a\\u021c\\u021e\\u0220\\u0222\\u0224\\u0226\\u0228\\u022a\\u022c\\u022e\\u0230\\u0232\\u023a\\u023b\\u023d\\u023e\\u0241\\u0243-\\u0246\\u0248\\u024a\\u024c\\u024e";
+var REGEXP_WORD = new RegExp("(?:[" + upperCaseLetter + "][" + diacriticalMark + "]*)?(?:[" + lowerCaseLetter + "][" + diacriticalMark + "]*)+|(?:[" + upperCaseLetter + "][" + diacriticalMark + "]*)+(?![" + lowerCaseLetter + "])|[" + digit + "]+|[" + dingbatBlock + "]|[^" + nonCharacter + generalPunctuationBlock + whitespace + "]+", "g");
+var REGEXP_LATIN_WORD = /[A-Z\xC0-\xD6\xD8-\xDE]?[a-z\xDF-\xF6\xF8-\xFF]+|[A-Z\xC0-\xD6\xD8-\xDE]+(?![a-z\xDF-\xF6\xF8-\xFF])|\d+/g;
+var REGEXP_ALPHA = new RegExp("^(?:[" + lowerCaseLetter + upperCaseLetter + "][" + diacriticalMark + "]*)+$");
+var REGEXP_ALPHA_DIGIT = new RegExp("^((?:[" + lowerCaseLetter + upperCaseLetter + "][" + diacriticalMark + "]*)|[" + digit + "])+$");
+var REGEXP_EXTENDED_ASCII = /^[\x01-\xFF]*$/;
+function nilDefault(value, defaultValue) {
+  return value == null ? defaultValue : value;
+}
+function toString(value) {
+  if (isNil(value)) {
+    return null;
+  }
+  if (isString(value)) {
+    return value;
+  }
+  return String(value);
+}
+function words(subject, pattern, flags) {
+  var subjectString = coerceToString(subject);
+  var patternRegExp;
+  if (isNil(pattern)) {
+    patternRegExp = REGEXP_EXTENDED_ASCII.test(subjectString) ? REGEXP_LATIN_WORD : REGEXP_WORD;
+  } else if (pattern instanceof RegExp) {
+    patternRegExp = pattern;
+  } else {
+    var flagsString = toString(nilDefault(flags, ""));
+    patternRegExp = new RegExp(toString(pattern), flagsString);
+  }
+  return nilDefault(subjectString.match(patternRegExp), []);
+}
+function wordToCamel(word, index) {
+  return index === 0 ? lowerCase(word) : capitalize(word, true);
+}
+function camelCase(subject) {
+  var subjectString = coerceToString(subject);
+  if (subjectString === "") {
+    return "";
+  }
+  return words(subjectString).map(wordToCamel).join("");
+}
+function decapitalize(subject) {
+  var subjectString = coerceToString(subject);
+  if (subjectString === "") {
+    return "";
+  }
+  return subjectString.substr(0, 1).toLowerCase() + subjectString.substr(1);
+}
+function kebabCase(subject) {
+  var subjectString = coerceToString(subject);
+  if (subjectString === "") {
+    return "";
+  }
+  return words(subjectString).map(lowerCase).join("-");
+}
+function snakeCase(subject) {
+  var subjectString = coerceToString(subject);
+  if (subjectString === "") {
+    return "";
+  }
+  return words(subjectString).map(lowerCase).join("_");
+}
+function upperCase(subject) {
+  var subjectString = coerceToString(subject);
+  return subjectString.toUpperCase();
+}
+function swapCase(subject) {
+  var subjectString = coerceToString(subject);
+  return subjectString.split("").reduce(swapAndConcat, "");
+}
+function swapAndConcat(swapped, character) {
+  var lowerCase2 = character.toLowerCase();
+  var upperCase2 = character.toUpperCase();
+  return swapped + (character === lowerCase2 ? upperCase2 : lowerCase2);
+}
+function titleCase(subject, noSplit) {
+  var subjectString = coerceToString(subject);
+  var noSplitArray = Array.isArray(noSplit) ? noSplit : [];
+  var wordsRegExp = REGEXP_EXTENDED_ASCII.test(subjectString) ? REGEXP_LATIN_WORD : REGEXP_WORD;
+  return subjectString.replace(wordsRegExp, function(word, index) {
+    var isNoSplit = index > 0 && noSplitArray.indexOf(subjectString[index - 1]) >= 0;
+    return isNoSplit ? word.toLowerCase() : capitalize(word, true);
+  });
+}
+function clipNumber(value, downLimit, upLimit) {
+  if (value <= downLimit) {
+    return downLimit;
+  }
+  if (value >= upLimit) {
+    return upLimit;
+  }
+  return value;
+}
+var MAX_SAFE_INTEGER = 9007199254740991;
+function toInteger(value) {
+  if (value === Infinity) {
+    return MAX_SAFE_INTEGER;
+  }
+  if (value === -Infinity) {
+    return -MAX_SAFE_INTEGER;
+  }
+  return ~~value;
+}
+function truncate(subject, length, end) {
+  var subjectString = coerceToString(subject);
+  var lengthInt = isNil(length) ? subjectString.length : clipNumber(toInteger(length), 0, MAX_SAFE_INTEGER);
+  var endString = coerceToString(end, "...");
+  if (lengthInt >= subjectString.length) {
+    return subjectString;
+  }
+  return subjectString.substr(0, length - endString.length) + endString;
+}
+function charAt(subject, position) {
+  var subjectString = coerceToString(subject);
+  return subjectString.charAt(position);
+}
+var HIGH_SURROGATE_START = 55296;
+var HIGH_SURROGATE_END = 56319;
+var LOW_SURROGATE_START = 56320;
+var LOW_SURROGATE_END = 57343;
+function isHighSurrogate(codePoint) {
+  return codePoint >= HIGH_SURROGATE_START && codePoint <= HIGH_SURROGATE_END;
+}
+function isLowSurrogate(codePoint) {
+  return codePoint >= LOW_SURROGATE_START && codePoint <= LOW_SURROGATE_END;
+}
+function getAstralNumberFromSurrogatePair(highSurrogate2, lowSurrogate2) {
+  return (highSurrogate2 - HIGH_SURROGATE_START) * 1024 + lowSurrogate2 - LOW_SURROGATE_START + 65536;
+}
+function coerceToNumber(value) {
+  var defaultValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+  if (isNil(value)) {
+    return defaultValue;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  return Number(value);
+}
+function nanDefault(value, defaultValue) {
+  return value !== value ? defaultValue : value;
+}
+function codePointAt(subject, position) {
+  var subjectString = coerceToString(subject);
+  var subjectStringLength = subjectString.length;
+  var positionNumber = coerceToNumber(position);
+  positionNumber = nanDefault(positionNumber, 0);
+  if (positionNumber < 0 || positionNumber >= subjectStringLength) {
+    return void 0;
+  }
+  var firstCodePoint = subjectString.charCodeAt(positionNumber);
+  var secondCodePoint;
+  if (isHighSurrogate(firstCodePoint) && subjectStringLength > positionNumber + 1) {
+    secondCodePoint = subjectString.charCodeAt(positionNumber + 1);
+    if (isLowSurrogate(secondCodePoint)) {
+      return getAstralNumberFromSurrogatePair(firstCodePoint, secondCodePoint);
+    }
+  }
+  return firstCodePoint;
+}
+function first(subject, length) {
+  var subjectString = coerceToString(subject);
+  var lengthInt = isNil(length) ? 1 : clipNumber(toInteger(length), 0, MAX_SAFE_INTEGER);
+  if (subjectString.length <= lengthInt) {
+    return subjectString;
+  }
+  return subjectString.substr(0, lengthInt);
+}
+function graphemeAt(subject, position) {
+  var subjectString = coerceToString(subject);
+  var positionNumber = coerceToNumber(position);
+  var graphemeMatch;
+  var graphemeMatchIndex = 0;
+  positionNumber = nanDefault(positionNumber, 0);
+  while ((graphemeMatch = REGEXP_UNICODE_CHARACTER.exec(subjectString)) !== null) {
+    if (graphemeMatchIndex === positionNumber) {
+      REGEXP_UNICODE_CHARACTER.lastIndex = 0;
+      return graphemeMatch[0];
+    }
+    graphemeMatchIndex++;
+  }
+  return "";
+}
+function last(subject, length) {
+  var subjectString = coerceToString(subject);
+  var lengthInt = isNil(length) ? 1 : clipNumber(toInteger(length), 0, MAX_SAFE_INTEGER);
+  if (subjectString.length <= lengthInt) {
+    return subjectString;
+  }
+  return subjectString.substr(subjectString.length - lengthInt, lengthInt);
+}
+function prune(subject, length, end) {
+  var subjectString = coerceToString(subject);
+  var lengthInt = isNil(length) ? subjectString.length : clipNumber(toInteger(length), 0, MAX_SAFE_INTEGER);
+  var endString = coerceToString(end, "...");
+  if (lengthInt >= subjectString.length) {
+    return subjectString;
+  }
+  var pattern = REGEXP_EXTENDED_ASCII.test(subjectString) ? REGEXP_LATIN_WORD : REGEXP_WORD;
+  var truncatedLength = 0;
+  subjectString.replace(pattern, function(word, offset) {
+    var wordInsertLength = offset + word.length;
+    if (wordInsertLength <= lengthInt - endString.length) {
+      truncatedLength = wordInsertLength;
+    }
+  });
+  return subjectString.substr(0, truncatedLength) + endString;
+}
+function slice(subject, start, end) {
+  return coerceToString(subject).slice(start, end);
+}
+function substr(subject, start, length) {
+  return coerceToString(subject).substr(start, length);
+}
+function substring(subject, start, end) {
+  return coerceToString(subject).substring(start, end);
+}
+function count(subject) {
+  return coerceToString(subject).length;
+}
+function countGrapheme(subject) {
+  return coerceToString(subject).replace(REGEXP_COMBINING_MARKS, "*").replace(REGEXP_SURROGATE_PAIRS, "*").length;
+}
+function countSubstrings(subject, substring2) {
+  var subjectString = coerceToString(subject);
+  var substringString = coerceToString(substring2);
+  var substringLength = substringString.length;
+  var count2 = 0;
+  var matchIndex = 0;
+  if (subjectString === "" || substringString === "") {
+    return count2;
+  }
+  do {
+    matchIndex = subjectString.indexOf(substringString, matchIndex);
+    if (matchIndex !== -1) {
+      count2++;
+      matchIndex += substringLength;
+    }
+  } while (matchIndex !== -1);
+  return count2;
+}
+var reduce = Array.prototype.reduce;
+function countWhere(subject, predicate, context) {
+  var subjectString = coerceToString(subject);
+  if (subjectString === "" || typeof predicate !== "function") {
+    return 0;
+  }
+  var predicateWithContext = predicate.bind(context);
+  return reduce.call(subjectString, function(countTruthy, character, index) {
+    return predicateWithContext(character, index, subjectString) ? countTruthy + 1 : countTruthy;
+  }, 0);
+}
+function countWords(subject, pattern, flags) {
+  return words(subject, pattern, flags).length;
+}
+function ReplacementIndex() {
+  this.index = 0;
+}
+ReplacementIndex.prototype.increment = function() {
+  this.index++;
+};
+ReplacementIndex.prototype.incrementOnEmptyPosition = function(position) {
+  if (isNil(position)) {
+    this.increment();
+  }
+};
+ReplacementIndex.prototype.getIndexByPosition = function(position) {
+  return isNil(position) ? this.index : position - 1;
+};
+var TYPE_INTEGER = "i";
+var TYPE_INTEGER_BINARY = "b";
+var TYPE_INTEGER_ASCII_CHARACTER = "c";
+var TYPE_INTEGER_DECIMAL = "d";
+var TYPE_INTEGER_OCTAL = "o";
+var TYPE_INTEGER_UNSIGNED_DECIMAL = "u";
+var TYPE_INTEGER_HEXADECIMAL = "x";
+var TYPE_INTEGER_HEXADECIMAL_UPPERCASE = "X";
+var TYPE_FLOAT_SCIENTIFIC = "e";
+var TYPE_FLOAT_SCIENTIFIC_UPPERCASE = "E";
+var TYPE_FLOAT = "f";
+var TYPE_FLOAT_SHORT = "g";
+var TYPE_FLOAT_SHORT_UPPERCASE = "G";
+var TYPE_STRING = "s";
+var LITERAL_SINGLE_QUOTE = "'";
+var LITERAL_PLUS = "+";
+var LITERAL_MINUS = "-";
+var LITERAL_PERCENT_SPECIFIER = "%%";
+var RADIX_BINARY = 2;
+var RADIX_OCTAL = 8;
+var RADIX_HEXADECIMAL = 16;
+function repeat(subject, times) {
+  var subjectString = coerceToString(subject);
+  var timesInt = isNil(times) ? 1 : clipNumber(toInteger(times), 0, MAX_SAFE_INTEGER);
+  var repeatString = "";
+  while (timesInt) {
+    if (timesInt & 1) {
+      repeatString += subjectString;
+    }
+    if (timesInt > 1) {
+      subjectString += subjectString;
+    }
+    timesInt >>= 1;
+  }
+  return repeatString;
+}
+function buildPadding(padCharacters, length) {
+  var padStringRepeat = toInteger(length / padCharacters.length);
+  var padStringRest = length % padCharacters.length;
+  return repeat(padCharacters, padStringRepeat + padStringRest).substr(0, length);
+}
+function padLeft(subject, length, pad2) {
+  var subjectString = coerceToString(subject);
+  var lengthInt = isNil(length) ? 0 : clipNumber(toInteger(length), 0, MAX_SAFE_INTEGER);
+  var padString = coerceToString(pad2, " ");
+  if (lengthInt <= subjectString.length) {
+    return subjectString;
+  }
+  return buildPadding(padString, lengthInt - subjectString.length) + subjectString;
+}
+function padRight(subject, length, pad2) {
+  var subjectString = coerceToString(subject);
+  var lengthInt = isNil(length) ? 0 : clipNumber(toInteger(length), 0, MAX_SAFE_INTEGER);
+  var padString = coerceToString(pad2, " ");
+  if (lengthInt <= subjectString.length) {
+    return subjectString;
+  }
+  return subjectString + buildPadding(padString, lengthInt - subjectString.length);
+}
+function alignAndPad(subject, conversion) {
+  var width = conversion.width;
+  if (isNil(width) || subject.length >= width) {
+    return subject;
+  }
+  var padType = conversion.alignmentSpecifier === LITERAL_MINUS ? padRight : padLeft;
+  return padType(subject, width, conversion.getPaddingCharacter());
+}
+function addSignToFormattedNumber(replacementNumber, formattedReplacement, conversion) {
+  if (conversion.signSpecifier === LITERAL_PLUS && replacementNumber >= 0) {
+    formattedReplacement = LITERAL_PLUS + formattedReplacement;
+  }
+  return formattedReplacement;
+}
+function float(replacement, conversion) {
+  var replacementNumber = parseFloat(replacement);
+  var formattedReplacement;
+  if (isNaN(replacementNumber)) {
+    replacementNumber = 0;
+  }
+  var precision = coerceToNumber(conversion.precision, 6);
+  switch (conversion.typeSpecifier) {
+    case TYPE_FLOAT:
+      formattedReplacement = replacementNumber.toFixed(precision);
+      break;
+    case TYPE_FLOAT_SCIENTIFIC:
+      formattedReplacement = replacementNumber.toExponential(precision);
+      break;
+    case TYPE_FLOAT_SCIENTIFIC_UPPERCASE:
+      formattedReplacement = replacementNumber.toExponential(precision).toUpperCase();
+      break;
+    case TYPE_FLOAT_SHORT:
+    case TYPE_FLOAT_SHORT_UPPERCASE:
+      formattedReplacement = formatFloatAsShort(replacementNumber, precision, conversion);
+      break;
+  }
+  formattedReplacement = addSignToFormattedNumber(replacementNumber, formattedReplacement, conversion);
+  return coerceToString(formattedReplacement);
+}
+function formatFloatAsShort(replacementNumber, precision, conversion) {
+  if (replacementNumber === 0) {
+    return "0";
+  }
+  var nonZeroPrecision = precision === 0 ? 1 : precision;
+  var formattedReplacement = replacementNumber.toPrecision(nonZeroPrecision).replace(REGEXP_TRAILING_ZEROS, "");
+  if (conversion.typeSpecifier === TYPE_FLOAT_SHORT_UPPERCASE) {
+    formattedReplacement = formattedReplacement.toUpperCase();
+  }
+  return formattedReplacement;
+}
+function integerBase(replacement, conversion) {
+  var integer = parseInt(replacement);
+  if (isNaN(integer)) {
+    integer = 0;
+  }
+  integer = integer >>> 0;
+  switch (conversion.typeSpecifier) {
+    case TYPE_INTEGER_ASCII_CHARACTER:
+      integer = String.fromCharCode(integer);
+      break;
+    case TYPE_INTEGER_BINARY:
+      integer = integer.toString(RADIX_BINARY);
+      break;
+    case TYPE_INTEGER_OCTAL:
+      integer = integer.toString(RADIX_OCTAL);
+      break;
+    case TYPE_INTEGER_HEXADECIMAL:
+      integer = integer.toString(RADIX_HEXADECIMAL);
+      break;
+    case TYPE_INTEGER_HEXADECIMAL_UPPERCASE:
+      integer = integer.toString(RADIX_HEXADECIMAL).toUpperCase();
+      break;
+  }
+  return coerceToString(integer);
+}
+function integerDecimal(replacement, conversion) {
+  var integer = parseInt(replacement);
+  if (isNaN(integer)) {
+    integer = 0;
+  }
+  return addSignToFormattedNumber(integer, toString(integer), conversion);
+}
+function stringFormat(replacement, conversion) {
+  var formattedReplacement = replacement;
+  var precision = conversion.precision;
+  if (!isNil(precision) && formattedReplacement.length > precision) {
+    formattedReplacement = truncate(formattedReplacement, precision, "");
+  }
+  return formattedReplacement;
+}
+function compute(replacement, conversion) {
+  var formatFunction;
+  switch (conversion.typeSpecifier) {
+    case TYPE_STRING:
+      formatFunction = stringFormat;
+      break;
+    case TYPE_INTEGER_DECIMAL:
+    case TYPE_INTEGER:
+      formatFunction = integerDecimal;
+      break;
+    case TYPE_INTEGER_ASCII_CHARACTER:
+    case TYPE_INTEGER_BINARY:
+    case TYPE_INTEGER_OCTAL:
+    case TYPE_INTEGER_HEXADECIMAL:
+    case TYPE_INTEGER_HEXADECIMAL_UPPERCASE:
+    case TYPE_INTEGER_UNSIGNED_DECIMAL:
+      formatFunction = integerBase;
+      break;
+    case TYPE_FLOAT:
+    case TYPE_FLOAT_SCIENTIFIC:
+    case TYPE_FLOAT_SCIENTIFIC_UPPERCASE:
+    case TYPE_FLOAT_SHORT:
+    case TYPE_FLOAT_SHORT_UPPERCASE:
+      formatFunction = float;
+      break;
+  }
+  var formattedString = formatFunction(replacement, conversion);
+  return alignAndPad(formattedString, conversion);
+}
+function ConversionSpecification(properties) {
+  this.percent = properties.percent;
+  this.signSpecifier = properties.signSpecifier;
+  this.paddingSpecifier = properties.paddingSpecifier;
+  this.alignmentSpecifier = properties.alignmentSpecifier;
+  this.width = properties.width;
+  this.precision = properties.precision;
+  this.typeSpecifier = properties.typeSpecifier;
+}
+ConversionSpecification.prototype.isPercentLiteral = function() {
+  return LITERAL_PERCENT_SPECIFIER === this.percent;
+};
+ConversionSpecification.prototype.getPaddingCharacter = function() {
+  var paddingCharacter = nilDefault(this.paddingSpecifier, " ");
+  if (paddingCharacter.length === 2 && paddingCharacter[0] === LITERAL_SINGLE_QUOTE) {
+    paddingCharacter = paddingCharacter[1];
+  }
+  return paddingCharacter;
+};
+function validate(index, replacementsLength, conversion) {
+  if (isNil(conversion.typeSpecifier)) {
+    throw new Error("sprintf(): Unknown type specifier");
+  }
+  if (index > replacementsLength - 1) {
+    throw new Error("sprintf(): Too few arguments");
+  }
+  if (index < 0) {
+    throw new Error("sprintf(): Argument number must be greater than zero");
+  }
+}
+function match(replacementIndex, replacements, conversionSpecification, percent, position, signSpecifier, paddingSpecifier, alignmentSpecifier, widthSpecifier, precisionSpecifier, typeSpecifier) {
+  var conversion = new ConversionSpecification({
+    percent,
+    signSpecifier,
+    paddingSpecifier,
+    alignmentSpecifier,
+    width: coerceToNumber(widthSpecifier, null),
+    precision: coerceToNumber(precisionSpecifier, null),
+    typeSpecifier
+  });
+  if (conversion.isPercentLiteral()) {
+    return conversionSpecification.slice(1);
+  }
+  var actualReplacementIndex = replacementIndex.getIndexByPosition(position);
+  replacementIndex.incrementOnEmptyPosition(position);
+  validate(actualReplacementIndex, replacements.length, conversion);
+  return compute(replacements[actualReplacementIndex], conversion);
+}
+function sprintf(format) {
+  var formatString = coerceToString(format);
+  if (formatString === "") {
+    return formatString;
+  }
+  for (var _len = arguments.length, replacements = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    replacements[_key - 1] = arguments[_key];
+  }
+  var boundReplacementMatch = match.bind(void 0, new ReplacementIndex(), replacements);
+  return formatString.replace(REGEXP_CONVERSION_SPECIFICATION, boundReplacementMatch);
+}
+function vprintf(format, replacements) {
+  return sprintf.apply(void 0, [format].concat(_toConsumableArray(nilDefault(replacements, []))));
+}
+var escapeCharactersMap = {
+  "<": "&lt;",
+  ">": "&gt;",
+  "&": "&amp;",
+  '"': "&quot;",
+  "'": "&#x27;",
+  "`": "&#x60;"
+};
+function replaceSpecialCharacter(character) {
+  return escapeCharactersMap[character];
+}
+function escapeHtml(subject) {
+  return coerceToString(subject).replace(REGEXP_HTML_SPECIAL_CHARACTERS, replaceSpecialCharacter);
+}
+function escapeRegExp2(subject) {
+  return coerceToString(subject).replace(REGEXP_SPECIAL_CHARACTERS, "\\$&");
+}
+var unescapeCharactersMap = {
+  "<": /(&lt;)|(&#x0*3c;)|(&#0*60;)/gi,
+  ">": /(&gt;)|(&#x0*3e;)|(&#0*62;)/gi,
+  "&": /(&amp;)|(&#x0*26;)|(&#0*38;)/gi,
+  '"': /(&quot;)|(&#x0*22;)|(&#0*34;)/gi,
+  "'": /(&#x0*27;)|(&#0*39;)/gi,
+  "`": /(&#x0*60;)|(&#0*96;)/gi
+};
+var characters = Object.keys(unescapeCharactersMap);
+function reduceUnescapedString(string, key) {
+  return string.replace(unescapeCharactersMap[key], key);
+}
+function unescapeHtml(subject) {
+  var subjectString = coerceToString(subject);
+  return characters.reduce(reduceUnescapedString, subjectString);
+}
+function indexOf(subject, search2, fromIndex) {
+  var subjectString = coerceToString(subject);
+  return subjectString.indexOf(search2, fromIndex);
+}
+function lastIndexOf(subject, search2, fromIndex) {
+  var subjectString = coerceToString(subject);
+  return subjectString.lastIndexOf(search2, fromIndex);
+}
+function search(subject, pattern, fromIndex) {
+  var subjectString = coerceToString(subject);
+  var fromIndexNumber = isNil(fromIndex) ? 0 : clipNumber(toInteger(fromIndex), 0, subjectString.length);
+  var matchIndex = subjectString.substr(fromIndexNumber).search(pattern);
+  if (matchIndex !== -1 && !isNaN(fromIndexNumber)) {
+    matchIndex += fromIndexNumber;
+  }
+  return matchIndex;
+}
+function insert(subject, toInsert, position) {
+  var subjectString = coerceToString(subject);
+  var toInsertString = coerceToString(toInsert);
+  var positionNumber = coerceToNumber(position);
+  if (positionNumber < 0 || positionNumber > subjectString.length || toInsertString === "") {
+    return subjectString;
+  }
+  return subjectString.slice(0, positionNumber) + toInsertString + subjectString.slice(positionNumber);
+}
+var diacritics = {
+  "3": "\u039E\u03BE",
+  "8": "\u0398\u03B8",
+  A: "A\xC0\xC1\xC2\xC3\xC4\xC5\u0100\u0102\u0104\u01CD\u01DE\u01E0\u01FA\u0200\u0202\u0226\u023A\u0386\u0391\u0410",
+  B: "B\u0181\u0182\u0243\u0392\u0411",
+  C: "C\xC7\u0106\u0108\u010A\u010C\u0187\u023B\u0426",
+  D: "D\u010E\u0110\u0189\u018A\u018B\xD0\u0394\u0414",
+  E: "E\xC8\xC9\xCA\xCB\u0112\u0114\u0116\u0118\u011A\u018E\u0190\u0204\u0206\u0228\u0388\u0395\u0415\u042D",
+  F: "F\u0191\u03A6\u0424",
+  G: "G\u011C\u011E\u0120\u0122\u0193\u01E4\u01E6\u01F4\u0393\u0413\u0490",
+  H: "H\u0124\u0126\u021E\u0389\u0397\u0425",
+  I: "I\xCC\xCD\xCE\xCF\u0128\u012A\u012C\u012E\u0130\u0197\u01CF\u0208\u020A\u038A\u0399\u03AA\u0406\u0418",
+  J: "J\u0134\u0248\u0419",
+  K: "K\u0136\u0198\u01E8\u039A\u041A",
+  L: "L\u0139\u013B\u013D\u013F\u0141\u023D\u039B\u041B",
+  M: "M\u019C\u039C\u041C",
+  N: "N\xD1\u0143\u0145\u0147\u019D\u01F8\u0220\u039D\u041D",
+  O: "O\xD2\xD3\xD4\xD5\xD6\xD8\u014C\u014E\u0150\u0186\u019F\u01A0\u01D1\u01EA\u01EC\u01FE\u020C\u020E\u022A\u022C\u022E\u0230\u038C\u039F\u041E",
+  P: "P\u01A4\u03A0\u041F",
+  Q: "Q\u024A",
+  R: "R\u0154\u0156\u0158\u0210\u0212\u024C\u03A1\u0420",
+  S: "S\u015A\u015C\u015E\u0160\u0218\u03A3\u0421",
+  T: "T\u0162\u0164\u0166\u01AC\u01AE\u021A\u023E\u03A4\u0422",
+  U: "U\xD9\xDA\xDB\xDC\u0168\u016A\u016C\u016E\u0170\u0172\u01AF\u01D3\u01D5\u01D7\u01D9\u01DB\u0214\u0216\u0244\u0423\u042A",
+  V: "V\u01B2\u0245\u0412",
+  W: "W\u0174\u038F\u03A9",
+  X: "X\u03A7",
+  Y: "Y\xDD\u0176\u0178\u01B3\u0232\u024E\u038E\u03A5\u03AB\u042B",
+  Z: "Z\u0179\u017B\u017D\u01B5\u0224\u0396\u0417",
+  a: "a\xE0\xE1\xE2\xE3\xE4\xE5\u0101\u0103\u0105\u01CE\u01DF\u01E1\u01FB\u0201\u0203\u0227\u0250\u03AC\u03B1\u0430",
+  b: "b\u0180\u0183\u0253\u03B2\u0431",
+  c: "c\xE7\u0107\u0109\u010B\u010D\u0188\u023C\u0446",
+  d: "d\u010F\u0111\u018C\u0256\u0257\xF0\u03B4\u0434",
+  e: "e\xE8\xE9\xEA\xEB\u0113\u0115\u0117\u0119\u011B\u01DD\u0205\u0207\u0229\u0247\u025B\u03AD\u03B5\u0435\u044D",
+  f: "f\u0192\u03C6\u0444",
+  g: "g\u011D\u011F\u0121\u0123\u01E5\u01E7\u01F5\u0260\u03B3\u0433\u0491",
+  h: "h\u0125\u0127\u021F\u0265\u03AE\u03B7\u0445",
+  i: "i\xEC\xED\xEE\xEF\u0129\u012B\u012D\u012F\u0131\u01D0\u0209\u020B\u0268\u0390\u03AF\u03B9\u03CA\u0438\u0456",
+  j: "j\u0135\u01F0\u0249\u0439",
+  k: "k\u0137\u0199\u01E9\u03BA\u043A",
+  l: "l\u013A\u013C\u013E\u0140\u0142\u017F\u019A\u026B\u03BB\u043B",
+  m: "m\u026F\u0271\u03BC\u043C",
+  n: "n\xF1\u0144\u0146\u0148\u0149\u019E\u01F9\u0272\u03BD\u043D",
+  o: "o\xF2\xF3\xF4\xF5\xF6\xF8\u014D\u014F\u0151\u01A1\u01D2\u01EB\u01ED\u01FF\u020D\u020F\u022B\u022D\u022F\u0231\u0254\u0275\u03BF\u03CC\u043E",
+  p: "p\u01A5\u03C0\u043F",
+  q: "q\u024B",
+  r: "r\u0155\u0157\u0159\u0211\u0213\u024D\u027D\u03C1\u0440",
+  s: "s\xDF\u015B\u015D\u015F\u0161\u0219\u023F\u03C2\u03C3\u0441",
+  t: "t\u0163\u0165\u0167\u01AD\u021B\u0288\u03C4\u0442",
+  u: "u\xF9\xFA\xFB\xFC\u0169\u016B\u016D\u016F\u0171\u0173\u01B0\u01D4\u01D6\u01D8\u01DA\u01DC\u0215\u0217\u0289\u0443\u044A",
+  v: "v\u028B\u028C\u0432",
+  w: "w\u0175\u03C9\u03CE",
+  x: "x\u03C7",
+  y: "y\xFD\xFF\u0177\u01B4\u0233\u024F\u03B0\u03C5\u03CB\u03CD\u044B",
+  z: "z\u017A\u017C\u017E\u01B6\u0225\u0240\u03B6\u0437",
+  OE: "\x8C\u0152",
+  oe: "\x9C\u0153",
+  AE: "\xC6\u01E2\u01FC",
+  ae: "\xE6\u01E3\u01FD",
+  hv: "\u0195",
+  OI: "\u01A2",
+  oi: "\u01A3",
+  DZ: "\u01C4\u01F1",
+  Dz: "\u01C5\u01F2",
+  dz: "\u01C6\u01F3",
+  LJ: "\u01C7",
+  Lj: "\u01C8",
+  lj: "\u01C9",
+  NJ: "\u01CA",
+  Nj: "\u01CB",
+  nj: "\u01CC",
+  OU: "\u0222",
+  ou: "\u0223",
+  TH: "\xDE",
+  th: "\xFE",
+  PS: "\u03A8",
+  ps: "\u03C8",
+  Yo: "\u0401",
+  Ye: "\u0404",
+  Yi: "\u0407",
+  Zh: "\u0416",
+  Ch: "\u0427",
+  Sh: "\u0428\u0429",
+  "": "\u042A\u042C\u044C",
+  Yu: "\u042E",
+  Ya: "\u042F",
+  zh: "\u0436",
+  ch: "\u0447",
+  sh: "\u0448\u0449",
+  yu: "\u044E",
+  ya: "\u044F",
+  yo: "\u0451",
+  ye: "\u0454",
+  yi: "\u0457"
+};
+var diacriticsMap = null;
+function getDiacriticsMap() {
+  if (diacriticsMap !== null) {
+    return diacriticsMap;
+  }
+  diacriticsMap = {};
+  Object.keys(diacritics).forEach(function(key) {
+    var characters2 = diacritics[key];
+    for (var index = 0; index < characters2.length; index++) {
+      var character = characters2[index];
+      diacriticsMap[character] = key;
+    }
+  });
+  return diacriticsMap;
+}
+function getLatinCharacter(character) {
+  var characterWithoutDiacritic = getDiacriticsMap()[character];
+  return characterWithoutDiacritic ? characterWithoutDiacritic : character;
+}
+function removeCombiningMarks(character, cleanCharacter) {
+  return cleanCharacter;
+}
+function latinise(subject) {
+  var subjectString = coerceToString(subject);
+  if (subjectString === "") {
+    return "";
+  }
+  return subjectString.replace(REGEXP_NON_LATIN, getLatinCharacter).replace(REGEXP_COMBINING_MARKS, removeCombiningMarks);
+}
+function pad(subject, length, pad2) {
+  var subjectString = coerceToString(subject);
+  var lengthInt = isNil(length) ? 0 : clipNumber(toInteger(length), 0, MAX_SAFE_INTEGER);
+  var padString = coerceToString(pad2, " ");
+  if (lengthInt <= subjectString.length) {
+    return subjectString;
+  }
+  var paddingLength = lengthInt - subjectString.length;
+  var paddingSideLength = toInteger(paddingLength / 2);
+  var paddingSideRemainingLength = paddingLength % 2;
+  return buildPadding(padString, paddingSideLength) + subjectString + buildPadding(padString, paddingSideLength + paddingSideRemainingLength);
+}
+function replace(subject, search2, replace2) {
+  var subjectString = coerceToString(subject);
+  return subjectString.replace(search2, replace2);
+}
+function replaceAll(subject, search2, replace2) {
+  var subjectString = coerceToString(subject);
+  if (search2 instanceof RegExp) {
+    if (search2.flags.indexOf("g") === -1) {
+      throw new TypeError("search argument is a non-global regular expression");
+    }
+    return subjectString.replace(search2, replace2);
+  }
+  var searchString = coerceToString(search2);
+  var isFunctionalReplace = typeof replace2 === "function";
+  if (!isFunctionalReplace) {
+    replace2 = coerceToString(replace2);
+  }
+  var searchLength = searchString.length;
+  if (searchLength === 0) {
+    return replaceAll(subject, /(?:)/g, replace2);
+  }
+  var advanceBy = searchLength > 1 ? searchLength : 1;
+  var matchPositions = [];
+  var position = subjectString.indexOf(searchString, 0);
+  while (position !== -1) {
+    matchPositions.push(position);
+    position = subjectString.indexOf(searchString, position + advanceBy);
+  }
+  var endOfLastMatch = 0;
+  var result = "";
+  for (var i = 0; i < matchPositions.length; i++) {
+    var _position = matchPositions[i];
+    var replacement = replace2;
+    if (isFunctionalReplace) {
+      replacement = coerceToString(replace2.call(void 0, searchString, _position, subjectString));
+    }
+    result += subjectString.slice(endOfLastMatch, _position) + replacement;
+    endOfLastMatch = _position + searchLength;
+  }
+  if (endOfLastMatch < subjectString.length) {
+    result += subjectString.slice(endOfLastMatch);
+  }
+  return result;
+}
+function reverse(subject) {
+  var subjectString = coerceToString(subject);
+  return subjectString.split("").reverse().join("");
+}
+function reverseGrapheme(subject) {
+  var subjectString = coerceToString(subject);
+  subjectString = subjectString.replace(REGEXP_COMBINING_MARKS, function($0, $1, $2) {
+    return reverseGrapheme($2) + $1;
+  }).replace(REGEXP_SURROGATE_PAIRS, "$2$1");
+  var reversedString = "";
+  var index = subjectString.length;
+  while (index--) {
+    reversedString += subjectString.charAt(index);
+  }
+  return reversedString;
+}
+function slugify(subject) {
+  var subjectString = coerceToString(subject);
+  if (subjectString === "") {
+    return "";
+  }
+  var cleanSubjectString = latinise(subjectString).replace(REGEXP_NON_LATIN, "-");
+  return kebabCase(cleanSubjectString);
+}
+function splice(subject, start, deleteCount, toAdd) {
+  var subjectString = coerceToString(subject);
+  var toAddString = coerceToString(toAdd);
+  var startPosition = coerceToNumber(start);
+  if (startPosition < 0) {
+    startPosition = subjectString.length + startPosition;
+    if (startPosition < 0) {
+      startPosition = 0;
+    }
+  } else if (startPosition > subjectString.length) {
+    startPosition = subjectString.length;
+  }
+  var deleteCountNumber = coerceToNumber(deleteCount, subjectString.length - startPosition);
+  if (deleteCountNumber < 0) {
+    deleteCountNumber = 0;
+  }
+  return subjectString.slice(0, startPosition) + toAddString + subjectString.slice(startPosition + deleteCountNumber);
+}
+function tr(subject, from, to) {
+  var subjectString = coerceToString(subject);
+  var keys;
+  var values;
+  if (isString(from) && isString(to)) {
+    keys = from.split("");
+    values = to.split("");
+  } else {
+    var _extractKeysAndValues = extractKeysAndValues(nilDefault(from, {}));
+    var _extractKeysAndValues2 = _slicedToArray(_extractKeysAndValues, 2);
+    keys = _extractKeysAndValues2[0];
+    values = _extractKeysAndValues2[1];
+  }
+  var keysLength = keys.length;
+  if (keysLength === 0) {
+    return subjectString;
+  }
+  var result = "";
+  var valuesLength = values.length;
+  for (var index = 0; index < subjectString.length; index++) {
+    var isMatch = false;
+    var matchValue = void 0;
+    for (var keyIndex = 0; keyIndex < keysLength && keyIndex < valuesLength; keyIndex++) {
+      var key = keys[keyIndex];
+      if (subjectString.substr(index, key.length) === key) {
+        isMatch = true;
+        matchValue = values[keyIndex];
+        index = index + key.length - 1;
+        break;
+      }
+    }
+    result += isMatch ? matchValue : subjectString[index];
+  }
+  return result;
+}
+function extractKeysAndValues(object) {
+  var keys = Object.keys(object);
+  var values = keys.sort(sortStringByLength).map(function(key) {
+    return object[key];
+  });
+  return [keys, values];
+}
+function sortStringByLength(str1, str2) {
+  if (str1.length === str2.length) {
+    return 0;
+  }
+  return str1.length < str2.length ? 1 : -1;
+}
+function includes(subject, search2, position) {
+  var subjectString = coerceToString(subject);
+  var searchString = toString(search2);
+  if (searchString === null) {
+    return false;
+  }
+  if (searchString === "") {
+    return true;
+  }
+  position = isNil(position) ? 0 : clipNumber(toInteger(position), 0, subjectString.length);
+  return subjectString.indexOf(searchString, position) !== -1;
+}
+var reduce$1 = Array.prototype.reduce;
+function trimLeft(subject, whitespace2) {
+  var subjectString = coerceToString(subject);
+  if (whitespace2 === "" || subjectString === "") {
+    return subjectString;
+  }
+  var whitespaceString = toString(whitespace2);
+  if (isNil(whitespaceString)) {
+    return subjectString.replace(REGEXP_TRIM_LEFT, "");
+  }
+  var matchWhitespace = true;
+  return reduce$1.call(subjectString, function(trimmed, character) {
+    if (matchWhitespace && includes(whitespaceString, character)) {
+      return trimmed;
+    }
+    matchWhitespace = false;
+    return trimmed + character;
+  }, "");
+}
+var reduceRight = Array.prototype.reduceRight;
+function trimRight(subject, whitespace2) {
+  var subjectString = coerceToString(subject);
+  if (whitespace2 === "" || subjectString === "") {
+    return subjectString;
+  }
+  var whitespaceString = toString(whitespace2);
+  if (isNil(whitespaceString)) {
+    return subjectString.replace(REGEXP_TRIM_RIGHT, "");
+  }
+  var matchWhitespace = true;
+  return reduceRight.call(subjectString, function(trimmed, character) {
+    if (matchWhitespace && includes(whitespaceString, character)) {
+      return trimmed;
+    }
+    matchWhitespace = false;
+    return character + trimmed;
+  }, "");
+}
+function trim(subject, whitespace2) {
+  var subjectString = coerceToString(subject);
+  if (whitespace2 === "" || subjectString === "") {
+    return subjectString;
+  }
+  var whitespaceString = toString(whitespace2);
+  if (isNil(whitespaceString)) {
+    return subjectString.trim();
+  }
+  return trimRight(trimLeft(subjectString, whitespaceString), whitespaceString);
+}
+var OPTION_WIDTH = "width";
+var OPTION_NEW_LINE = "newLine";
+var OPTION_INDENT = "indent";
+var OPTION_CUT = "cut";
+function wordWrap(subject) {
+  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var subjectString = coerceToString(subject);
+  var _determineOptions = determineOptions(options), width = _determineOptions.width, newLine = _determineOptions.newLine, indent = _determineOptions.indent, cut = _determineOptions.cut;
+  if (subjectString === "" || width <= 0) {
+    return indent;
+  }
+  var subjectLength = subjectString.length;
+  var substring2 = subjectString.substring.bind(subjectString);
+  var offset = 0;
+  var wrappedLine = "";
+  while (subjectLength - offset > width) {
+    if (subjectString[offset] === " ") {
+      offset++;
+      continue;
+    }
+    var spaceToWrapAt = subjectString.lastIndexOf(" ", width + offset);
+    if (spaceToWrapAt >= offset) {
+      wrappedLine += indent + substring2(offset, spaceToWrapAt) + newLine;
+      offset = spaceToWrapAt + 1;
+    } else {
+      if (cut) {
+        wrappedLine += indent + substring2(offset, width + offset) + newLine;
+        offset += width;
+      } else {
+        spaceToWrapAt = subjectString.indexOf(" ", width + offset);
+        if (spaceToWrapAt >= 0) {
+          wrappedLine += indent + substring2(offset, spaceToWrapAt) + newLine;
+          offset = spaceToWrapAt + 1;
+        } else {
+          wrappedLine += indent + substring2(offset);
+          offset = subjectLength;
+        }
+      }
+    }
+  }
+  if (offset < subjectLength) {
+    wrappedLine += indent + substring2(offset);
+  }
+  return wrappedLine;
+}
+function determineOptions(options) {
+  return {
+    width: coerceToNumber(options[OPTION_WIDTH], 75),
+    newLine: coerceToString(options[OPTION_NEW_LINE], "\n"),
+    indent: coerceToString(options[OPTION_INDENT], ""),
+    cut: coerceToBoolean(options[OPTION_CUT], false)
+  };
+}
+function endsWith(subject, end, position) {
+  if (isNil(end)) {
+    return false;
+  }
+  var subjectString = coerceToString(subject);
+  var endString = coerceToString(end);
+  if (endString === "") {
+    return true;
+  }
+  position = isNil(position) ? subjectString.length : clipNumber(toInteger(position), 0, subjectString.length);
+  position -= endString.length;
+  var lastIndex = subjectString.indexOf(endString, position);
+  return lastIndex !== -1 && lastIndex === position;
+}
+function isAlpha(subject) {
+  var subjectString = coerceToString(subject);
+  return REGEXP_ALPHA.test(subjectString);
+}
+function isAlphaDigit(subject) {
+  var subjectString = coerceToString(subject);
+  return REGEXP_ALPHA_DIGIT.test(subjectString);
+}
+function isBlank(subject) {
+  var subjectString = coerceToString(subject);
+  return subjectString.trim().length === 0;
+}
+function isDigit(subject) {
+  var subjectString = coerceToString(subject);
+  return REGEXP_DIGIT.test(subjectString);
+}
+function isEmpty(subject) {
+  var subjectString = coerceToString(subject);
+  return subjectString.length === 0;
+}
+function isLowerCase(subject) {
+  var valueString = coerceToString(subject);
+  return isAlpha(valueString) && valueString.toLowerCase() === valueString;
+}
+function isNumeric(subject) {
+  var valueNumeric = typeof subject === "object" && !isNil(subject) ? Number(subject) : subject;
+  return (typeof valueNumeric === "number" || typeof valueNumeric === "string") && !isNaN(valueNumeric - parseFloat(valueNumeric));
+}
+function isUpperCase(subject) {
+  var subjectString = coerceToString(subject);
+  return isAlpha(subjectString) && subjectString.toUpperCase() === subjectString;
+}
+function matches(subject, pattern, flags) {
+  var subjectString = coerceToString(subject);
+  var flagsString = coerceToString(flags);
+  var patternString;
+  if (!(pattern instanceof RegExp)) {
+    patternString = toString(pattern);
+    if (patternString === null) {
+      return false;
+    }
+    pattern = new RegExp(patternString, flagsString);
+  }
+  return pattern.test(subjectString);
+}
+function startsWith(subject, start, position) {
+  var subjectString = coerceToString(subject);
+  var startString = toString(start);
+  if (startString === null) {
+    return false;
+  }
+  if (startString === "") {
+    return true;
+  }
+  position = isNil(position) ? 0 : clipNumber(toInteger(position), 0, subjectString.length);
+  return subjectString.substr(position, startString.length) === startString;
+}
+function chars(subject) {
+  var subjectString = coerceToString(subject);
+  return subjectString.split("");
+}
+function codePoints(subject) {
+  var subjectString = coerceToString(subject);
+  var subjectStringLength = subjectString.length;
+  var codePointArray = [];
+  var index = 0;
+  var codePointNumber;
+  while (index < subjectStringLength) {
+    codePointNumber = codePointAt(subjectString, index);
+    codePointArray.push(codePointNumber);
+    index += codePointNumber > 65535 ? 2 : 1;
+  }
+  return codePointArray;
+}
+function graphemes(subject) {
+  var subjectString = coerceToString(subject);
+  return nilDefault(subjectString.match(REGEXP_UNICODE_CHARACTER), []);
+}
+function split(subject, separator, limit) {
+  var subjectString = coerceToString(subject);
+  return subjectString.split(separator, limit);
+}
+var BYRE_ORDER_MARK = "\uFEFF";
+function trim$1(subject) {
+  var subjectString = coerceToString(subject);
+  if (subjectString === "") {
+    return "";
+  }
+  if (subjectString[0] === BYRE_ORDER_MARK) {
+    return subjectString.substring(1);
+  }
+  return subjectString;
+}
+function hasSubstringAtIndex(subject, substring2, index) {
+  var lookBehind = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true;
+  var indexOffset = 0;
+  if (lookBehind) {
+    indexOffset = -substring2.length + 1;
+  }
+  var extractedSubstring = subject.substr(index + indexOffset, substring2.length);
+  return extractedSubstring.toLowerCase() === substring2;
+}
+function parseTagList(tags) {
+  var tagsList = [];
+  var match2;
+  while ((match2 = REGEXP_TAG_LIST.exec(tags)) !== null) {
+    tagsList.push(match2[1]);
+  }
+  return tagsList;
+}
+var STATE_START_TAG = 0;
+var STATE_NON_WHITESPACE = 1;
+var STATE_DONE = 2;
+function parseTagName(tagContent) {
+  var state = STATE_START_TAG;
+  var tagName = "";
+  var index = 0;
+  while (state !== STATE_DONE) {
+    var char = tagContent[index++].toLowerCase();
+    switch (char) {
+      case "<":
+        break;
+      case ">":
+        state = STATE_DONE;
+        break;
+      default:
+        if (REGEXP_WHITESPACE.test(char)) {
+          if (state === STATE_NON_WHITESPACE) {
+            state = STATE_DONE;
+          }
+        } else {
+          if (state === STATE_START_TAG) {
+            state = STATE_NON_WHITESPACE;
+          }
+          if (char !== "/") {
+            tagName += char;
+          }
+        }
+        break;
+    }
+  }
+  return tagName;
+}
+var STATE_OUTPUT = 0;
+var STATE_HTML = 1;
+var STATE_EXCLAMATION = 2;
+var STATE_COMMENT = 3;
+function trim$2(subject, allowableTags, replacement) {
+  subject = coerceToString(subject);
+  if (subject === "") {
+    return "";
+  }
+  if (!Array.isArray(allowableTags)) {
+    var allowableTagsString = coerceToString(allowableTags);
+    allowableTags = allowableTagsString === "" ? [] : parseTagList(allowableTagsString);
+  }
+  var replacementString = coerceToString(replacement);
+  var length = subject.length;
+  var hasAllowableTags = allowableTags.length > 0;
+  var hasSubstring = hasSubstringAtIndex.bind(null, subject);
+  var state = STATE_OUTPUT;
+  var depth = 0;
+  var output = "";
+  var tagContent = "";
+  var quote = null;
+  for (var index = 0; index < length; index++) {
+    var char = subject[index];
+    var advance = false;
+    switch (char) {
+      case "<":
+        if (quote) {
+          break;
+        }
+        if (hasSubstring("< ", index, false)) {
+          advance = true;
+          break;
+        }
+        if (state === STATE_OUTPUT) {
+          advance = true;
+          state = STATE_HTML;
+          break;
+        }
+        if (state === STATE_HTML) {
+          depth++;
+          break;
+        }
+        advance = true;
+        break;
+      case "!":
+        if (state === STATE_HTML && hasSubstring("<!", index)) {
+          state = STATE_EXCLAMATION;
+          break;
+        }
+        advance = true;
+        break;
+      case "-":
+        if (state === STATE_EXCLAMATION && hasSubstring("!--", index)) {
+          state = STATE_COMMENT;
+          break;
+        }
+        advance = true;
+        break;
+      case '"':
+      case "'":
+        if (state === STATE_HTML) {
+          if (quote === char) {
+            quote = null;
+          } else if (!quote) {
+            quote = char;
+          }
+        }
+        advance = true;
+        break;
+      case "E":
+      case "e":
+        if (state === STATE_EXCLAMATION && hasSubstring("doctype", index)) {
+          state = STATE_HTML;
+          break;
+        }
+        advance = true;
+        break;
+      case ">":
+        if (depth > 0) {
+          depth--;
+          break;
+        }
+        if (quote) {
+          break;
+        }
+        if (state === STATE_HTML) {
+          quote = null;
+          state = STATE_OUTPUT;
+          if (hasAllowableTags) {
+            tagContent += ">";
+            var tagName = parseTagName(tagContent);
+            if (allowableTags.indexOf(tagName.toLowerCase()) !== -1) {
+              output += tagContent;
+            } else {
+              output += replacementString;
+            }
+            tagContent = "";
+          } else {
+            output += replacementString;
+          }
+          break;
+        }
+        if (state === STATE_EXCLAMATION || state === STATE_COMMENT && hasSubstring("-->", index)) {
+          quote = null;
+          state = STATE_OUTPUT;
+          tagContent = "";
+          break;
+        }
+        advance = true;
+        break;
+      default:
+        advance = true;
+    }
+    if (advance) {
+      switch (state) {
+        case STATE_OUTPUT:
+          output += char;
+          break;
+        case STATE_HTML:
+          if (hasAllowableTags) {
+            tagContent += char;
+          }
+          break;
+      }
+    }
+  }
+  return output;
+}
+var globalObject = null;
+function getGlobalObject() {
+  if (globalObject !== null) {
+    return globalObject;
+  }
+  if (typeof global === "object" && global.Object === Object) {
+    globalObject = global;
+  } else if (typeof self === "object" && self.Object === Object) {
+    globalObject = self;
+  } else {
+    globalObject = new Function("return this")();
+  }
+  return globalObject;
+}
+var globalObject$1 = getGlobalObject();
+var previousV = globalObject$1.v;
+function noConflict() {
+  if (this === globalObject$1.v) {
+    globalObject$1.v = previousV;
+  }
+  return this;
+}
+var version = "1.4.0";
+var functions = {
+  camelCase,
+  capitalize,
+  decapitalize,
+  kebabCase,
+  lowerCase,
+  snakeCase,
+  swapCase,
+  titleCase,
+  upperCase,
+  count,
+  countGraphemes: countGrapheme,
+  countSubstrings,
+  countWhere,
+  countWords,
+  escapeHtml,
+  escapeRegExp: escapeRegExp2,
+  unescapeHtml,
+  sprintf,
+  vprintf,
+  indexOf,
+  lastIndexOf,
+  search,
+  charAt,
+  codePointAt,
+  first,
+  graphemeAt,
+  last,
+  prune,
+  slice,
+  substr,
+  substring,
+  truncate,
+  insert,
+  latinise,
+  pad,
+  padLeft,
+  padRight,
+  repeat,
+  replace,
+  replaceAll,
+  reverse,
+  reverseGrapheme,
+  slugify,
+  splice,
+  tr,
+  trim,
+  trimLeft,
+  trimRight,
+  wordWrap,
+  endsWith,
+  includes,
+  isAlpha,
+  isAlphaDigit,
+  isBlank,
+  isDigit,
+  isEmpty,
+  isLowerCase,
+  isNumeric,
+  isString,
+  isUpperCase,
+  matches,
+  startsWith,
+  chars,
+  codePoints,
+  graphemes,
+  split,
+  words,
+  stripBom: trim$1,
+  stripTags: trim$2,
+  noConflict,
+  version
+};
+function ChainWrapper(subject, explicitChain) {
+  this._wrappedValue = subject;
+  this._explicitChain = explicitChain;
+}
+ChainWrapper.prototype.value = function() {
+  return this._wrappedValue;
+};
+ChainWrapper.prototype.valueOf = function() {
+  return this.value();
+};
+ChainWrapper.prototype.toJSON = function() {
+  return this.value();
+};
+ChainWrapper.prototype.toString = function() {
+  return String(this.value());
+};
+ChainWrapper.prototype.chain = function() {
+  return new ChainWrapper(this._wrappedValue, true);
+};
+ChainWrapper.prototype.thru = function(changer) {
+  if (typeof changer === "function") {
+    return new ChainWrapper(changer(this._wrappedValue), this._explicitChain);
+  }
+  return this;
+};
+ChainWrapper.prototype._explicitChain = true;
+function makeFunctionChainable(functionInstance) {
+  return function() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var result = functionInstance.apply(void 0, [this._wrappedValue].concat(args));
+    if (this._explicitChain || typeof result === "string") {
+      return new ChainWrapper(result, this._explicitChain);
+    } else {
+      return result;
+    }
+  };
+}
+Object.keys(functions).forEach(function(name) {
+  ChainWrapper.prototype[name] = makeFunctionChainable(functions[name]);
+});
+function chain(subject) {
+  return new ChainWrapper(subject, true);
+}
+function Voca(subject) {
+  return new ChainWrapper(subject, false);
+}
+_extends(Voca, functions, {
+  chain
+});
+var es_default = Voca;
+
+// src/core/template/utils.ts
+function isWithinRoot(resolved, root) {
+  const normalizedRoot = root.endsWith(path__default.sep) ? root.slice(0, -1) : root;
+  return resolved === normalizedRoot || resolved.startsWith(normalizedRoot + path__default.sep);
+}
+function toContextKey(filename) {
+  const ext = path__default.extname(filename);
+  const base2 = path__default.basename(filename, ext);
+  return es_default.camelCase(base2);
+}
+function sqlEscape(value) {
+  return value.replace(/'/g, "''");
+}
+var UndefinedSqlValueError = class extends Error {
+  name = "UndefinedSqlValueError";
+  constructor() {
+    super("sqlQuote() received undefined \u2014 use null for an explicit SQL NULL, or resolve the missing value before rendering");
+  }
+};
+function sqlQuote(value) {
+  if (value === void 0) {
+    throw new UndefinedSqlValueError();
+  }
+  if (value === null) {
+    return "NULL";
+  }
+  return `'${sqlEscape(String(value))}'`;
+}
+function generateUuid() {
+  return crypto.randomUUID();
+}
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var IS_COMPILED = import.meta.url.includes("$bunfs");
+async function loadJs(filepath) {
+  const mod = IS_COMPILED ? await loadWithBunBuild(filepath) : await loadWithImport(filepath);
+  return mod["default"] !== void 0 ? mod["default"] : mod;
+}
+async function loadWithBunBuild(filepath) {
+  const fileDir = dirname(filepath);
+  const tmpFile = join(fileDir, `.noorm-helper-${randomBytes(8).toString("hex")}.js`);
+  const result = await Bun.build({
+    entrypoints: [filepath],
+    outdir: fileDir,
+    naming: tmpFile.split("/").pop(),
+    target: "bun",
+    format: "esm"
+  });
+  if (!result.success) {
+    const messages = result.logs.map((l) => l.message).join("; ");
+    throw new Error(`Failed to bundle ${filepath}: ${messages}`);
+  }
+  const mod = await import(pathToFileURL(tmpFile).href);
+  unlinkSync(tmpFile);
+  return mod;
+}
+async function loadWithImport(filepath) {
+  const url = pathToFileURL(filepath).href;
+  const urlWithCacheBust = `${url}?t=${Date.now()}`;
+  return await import(urlWithCacheBust);
+}
+
+// src/core/template/helpers.ts
+async function findHelperFiles(fromDir, projectRoot) {
+  const helperPaths = [];
+  let currentDir = path__default.resolve(fromDir);
+  const root = path__default.resolve(projectRoot);
+  while (isWithinRoot(currentDir, root)) {
+    const helperPath = await findHelperInDir(currentDir);
+    if (helperPath) {
+      helperPaths.unshift(helperPath);
+    }
+    const parentDir = path__default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return helperPaths;
+}
+async function findHelperInDir(dir) {
+  for (const ext of HELPER_EXTENSIONS) {
+    const filepath = path__default.join(dir, `${HELPER_FILENAME}${ext}`);
+    const [stats] = await attempt(() => stat(filepath));
+    if (stats?.isFile()) {
+      return filepath;
+    }
+  }
+  return null;
+}
+async function loadHelpers(fromDir, projectRoot) {
+  const helperPaths = await findHelperFiles(fromDir, projectRoot);
+  const merged = {};
+  const errors = [];
+  for (const filepath of helperPaths) {
+    const [mod, err] = await attempt(() => loadJs(filepath));
+    if (err) {
+      errors.push({ filepath, error: err });
+      observer.emit("error", {
+        source: "template",
+        error: err,
+        context: { filepath, operation: "load-helpers" }
+      });
+      continue;
+    }
+    if (mod && typeof mod === "object") {
+      const exports$1 = mod;
+      const exportCount = Object.keys(exports$1).length;
+      Object.assign(merged, exports$1);
+      observer.emit("template:helpers", {
+        filepath,
+        count: exportCount
+      });
+    }
+  }
+  return { helpers: merged, errors };
+}
+async function loadSql(filepath) {
+  return readFile$1(filepath, "utf-8");
+}
+
+// src/core/dt/constants.ts
+var FORMAT_VERSION = 1;
+var ENCODED_TYPES = {
+  json: true,
+  binary: true,
+  vector: true,
+  array: true,
+  text: true,
+  custom: true
+};
+var MAX_DECOMPRESSED_ARCHIVE_BYTES = 1024 * 1024 * 1024;
+var MAX_ROW_BYTES = 256 * 1024 * 1024;
+var DT_EXTENSIONS = {
+  /** Raw .dt file (uncompressed JSON5 lines). */
+  RAW: ".dt",
+  /** Gzip-compressed .dt file. */
+  COMPRESSED: ".dtz",
+  /** Gzip-compressed and AES-256-GCM encrypted .dt file. */
+  ENCRYPTED: ".dtzx"
+};
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 16;
+var SALT_LENGTH = 32;
+var AUTH_TAG_LENGTH = 16;
+var KEY_LENGTH = 32;
+var PBKDF2_ITERATIONS = 1e5;
+var PBKDF2_DIGEST = "sha256";
+var MIN_PASSPHRASE_LENGTH = 12;
+function encryptWithPassphrase(data, passphrase) {
+  if (passphrase.length < MIN_PASSPHRASE_LENGTH) {
+    throw new Error(`Passphrase must be at least ${MIN_PASSPHRASE_LENGTH} characters`);
+  }
+  const salt = randomBytes(SALT_LENGTH);
+  const iv = randomBytes(IV_LENGTH);
+  const key = pbkdf2Sync(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, PBKDF2_DIGEST);
+  const cipher = createCipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  return {
+    salt: salt.toString("base64"),
+    iv: iv.toString("base64"),
+    authTag: authTag.toString("base64"),
+    ciphertext: ciphertext.toString("base64")
+  };
+}
+function decryptWithPassphrase(payload, passphrase) {
+  const salt = Buffer.from(payload.salt, "base64");
+  const iv = Buffer.from(payload.iv, "base64");
+  const authTag = Buffer.from(payload.authTag, "base64");
+  const ciphertext = Buffer.from(payload.ciphertext, "base64");
+  const key = pbkdf2Sync(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, PBKDF2_DIGEST);
+  const decipher = createDecipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  decipher.setAuthTag(authTag);
+  const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  return decrypted;
+}
+
+// src/core/dt/reader.ts
+function createRowLengthGuard() {
+  let sinceNewline = 0;
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      const lastNewline = chunk.lastIndexOf(10);
+      sinceNewline = lastNewline === -1 ? sinceNewline + chunk.length : chunk.length - lastNewline - 1;
+      if (sinceNewline > MAX_ROW_BYTES) {
+        callback(new Error(`.dt row exceeds the ${MAX_ROW_BYTES} byte limit without a line break`));
+        return;
+      }
+      callback(null, chunk);
+    }
+  });
+}
+function assertDtSchema(parsed) {
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(".dt schema line is not an object");
+  }
+  const schema = parsed;
+  if (schema.v !== FORMAT_VERSION) {
+    throw new Error(`Unsupported .dt format version: ${String(schema.v)}`);
+  }
+  if (!Array.isArray(schema.columns) || schema.columns.length === 0) {
+    throw new Error('.dt schema is missing a non-empty "columns" array');
+  }
+  schema.columns.forEach((column, i) => {
+    if (typeof column !== "object" || column === null) {
+      throw new Error(`.dt schema column ${i} is not an object`);
+    }
+    if (typeof column.name !== "string" || column.name.length === 0) {
+      throw new Error(`.dt schema column ${i} is missing a "name"`);
+    }
+    if (typeof column.type !== "string" || column.type.length === 0) {
+      throw new Error(`.dt schema column "${column.name}" is missing a "type"`);
+    }
+  });
+  return schema;
+}
+function guardRows(source, ...upstream) {
+  const guard = createRowLengthGuard();
+  source.on("error", (err) => guard.destroy(err));
+  guard.on("close", () => {
+    for (const stream of [source, ...upstream]) {
+      stream.destroy();
+    }
+  });
+  return source.pipe(guard);
+}
+var DtReader = class {
+  #filepath;
+  #passphrase;
+  #extension;
+  #schema = null;
+  #lineReader = null;
+  #inputStream = null;
+  /**
+   * Create a new DtReader.
+   *
+   * @param options - File path and optional passphrase for .dtzx
+   */
+  constructor(options) {
+    this.#filepath = options.filepath;
+    this.#passphrase = options.passphrase;
+    this.#extension = path__default.extname(options.filepath).toLowerCase();
+  }
+  /** The parsed schema from line 1. Available after open(). */
+  get schema() {
+    return this.#schema;
+  }
+  /**
+   * Open the file and parse the schema header.
+   *
+   * Must be called before iterating rows.
+   */
+  async open() {
+    const readable = this.#createReadableStream();
+    this.#inputStream = readable;
+    const rl = createInterface({ input: readable, crlfDelay: Infinity });
+    const lines = rl[Symbol.asyncIterator]();
+    const firstLine = await lines.next();
+    if (firstLine.done || !firstLine.value) {
+      throw new Error("Empty .dt file \u2014 no schema line");
+    }
+    const [parsed, parseErr] = attemptSync(() => dist_default.parse(firstLine.value));
+    if (parseErr) {
+      throw new Error(`.dt schema line is not valid JSON5: ${parseErr.message}`);
+    }
+    this.#schema = assertDtSchema(parsed);
+    this.#lineReader = this.#createRowIterator(lines);
+  }
+  /**
+   * Async generator yielding parsed row value arrays.
+   *
+   * Each yield is a `DtValue[]` in column order matching the schema.
+   *
+   * @example
+   * ```typescript
+   * for await (const values of reader.rows()) {
+   *     console.log(values); // [1, "alice@example.com", true, "2024-01-15T10:30:00Z"]
+   * }
+   * ```
+   */
+  async *rows() {
+    if (!this.#lineReader) {
+      throw new Error("Reader not opened \u2014 call open() first");
+    }
+    yield* this.#lineReader;
+  }
+  /**
+   * Close the reader and release resources.
+   */
+  close() {
+    if (this.#inputStream) {
+      this.#inputStream.destroy();
+      this.#inputStream = null;
+    }
+  }
+  /**
+   * Create the readable stream based on file extension.
+   */
+  #createReadableStream() {
+    if (this.#extension === DT_EXTENSIONS.ENCRYPTED) {
+      if (!this.#passphrase) {
+        throw new Error("Passphrase required for .dtzx files");
+      }
+      const encrypted = readFileSync(this.#filepath, "utf8");
+      const payload = JSON.parse(encrypted);
+      const compressed = decryptWithPassphrase(payload, this.#passphrase);
+      const [raw, gunzipErr] = attemptSync(
+        () => gunzipSync(compressed, { maxOutputLength: MAX_DECOMPRESSED_ARCHIVE_BYTES })
+      );
+      if (gunzipErr || !raw) {
+        throw new Error(
+          `.dtzx archive exceeds the ${MAX_DECOMPRESSED_ARCHIVE_BYTES} byte decompression limit or is not valid gzip: ${gunzipErr?.message ?? "unknown error"}`
+        );
+      }
+      const stream = new PassThrough();
+      stream.end(raw);
+      return guardRows(stream);
+    }
+    if (this.#extension === DT_EXTENSIONS.COMPRESSED) {
+      const fileStream = createReadStream(this.#filepath);
+      const gunzip = createGunzip();
+      fileStream.on("error", (err) => gunzip.destroy(err));
+      fileStream.pipe(gunzip);
+      return guardRows(gunzip, fileStream);
+    }
+    return guardRows(createReadStream(this.#filepath));
+  }
+  /**
+   * Create async generator from remaining readline lines.
+   */
+  async *#createRowIterator(lines) {
+    const expected = this.#schema.columns.length;
+    let rowNumber = 0;
+    for await (const line of { [Symbol.asyncIterator]: () => lines }) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      rowNumber++;
+      const [values, parseErr] = attemptSync(() => dist_default.parse(trimmed));
+      if (parseErr) {
+        throw new Error(`.dt row ${rowNumber} is not valid JSON5: ${parseErr.message}`);
+      }
+      if (!Array.isArray(values)) {
+        throw new Error(`.dt row ${rowNumber} is not an array of values`);
+      }
+      if (values.length !== expected) {
+        throw new Error(
+          `.dt row ${rowNumber} has ${values.length} values but the schema declares ${expected} columns`
+        );
+      }
+      yield values;
+    }
+  }
+};
+
+// src/core/template/loaders/dt.ts
+async function loadDt(filepath) {
+  const reader = new DtReader({ filepath });
+  await reader.open();
+  const schema = reader.schema;
+  if (!schema) {
+    throw new Error(`Failed to read .dt schema from: ${filepath}`);
+  }
+  const columnNames = schema.columns.map((c) => c.name);
+  const rows = [];
+  for await (const values of reader.rows()) {
+    const row = {};
+    for (let i = 0; i < columnNames.length; i++) {
+      row[columnNames[i]] = values[i] ?? null;
+    }
+    rows.push(row);
+  }
+  reader.close();
+  return rows;
+}
+
+// src/core/template/loaders/index.ts
+async function lazyLoadJson5(filepath) {
+  const { loadJson5: loadJson52 } = await import('./json5-LNT3RGJ7.js');
+  return loadJson52(filepath);
+}
+async function lazyLoadYaml(filepath) {
+  const { loadYaml: loadYaml2 } = await import('./yaml-XI7RQ2D5.js');
+  return loadYaml2(filepath);
+}
+async function lazyLoadCsv(filepath) {
+  const { loadCsv: loadCsv2 } = await import('./csv-T5P3IN4K.js');
+  return loadCsv2(filepath);
+}
+var loaders = {
+  ".json": lazyLoadJson5,
+  ".json5": lazyLoadJson5,
+  ".yaml": lazyLoadYaml,
+  ".yml": lazyLoadYaml,
+  ".csv": lazyLoadCsv,
+  ".js": loadJs,
+  ".mjs": loadJs,
+  ".ts": loadJs,
+  ".sql": loadSql,
+  ".dt": loadDt,
+  ".dtz": loadDt
+  // NO .dtzx — can't provide passphrase in template context
+};
+var EXECUTABLE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".ts"]);
+function hasLoader(ext) {
+  return ext in loaders;
+}
+function isExecutableExtension(ext) {
+  return EXECUTABLE_EXTENSIONS.has(ext);
+}
+function getLoader(ext) {
+  return loaders[ext];
+}
+async function loadDataFile(filepath) {
+  const ext = path__default.extname(filepath).toLowerCase();
+  const loader = getLoader(ext);
+  if (!loader) {
+    throw new Error(`No loader registered for extension: ${ext}`);
+  }
+  return loader(filepath);
+}
+
+// src/core/template/context.ts
+var SECRET_TIERS_SEARCHED = ["config-local", "global-local", "vault"];
+var MissingSecretError = class extends Error {
+  constructor(key, tiersSearched = SECRET_TIERS_SEARCHED) {
+    super(`Secret "${key}" not found (searched: ${tiersSearched.join(", ")})`);
+    this.key = key;
+    this.tiersSearched = tiersSearched;
+  }
+  name = "MissingSecretError";
+};
+function createSecretsProxy(secrets) {
+  return new Proxy(secrets, {
+    get(target, prop, receiver) {
+      if (typeof prop === "symbol" || prop === "toJSON" || prop in target) {
+        return Reflect.get(target, prop, receiver);
+      }
+      throw new MissingSecretError(prop);
+    },
+    has(target, prop) {
+      return Reflect.has(target, prop);
+    }
+  });
+}
+async function buildContext(templatePath, options = {}) {
+  const templateDir = path__default.dirname(templatePath);
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const [templateSource] = await attempt(() => readFile$1(templatePath, "utf-8"));
+  const { helpers } = await loadHelpers(templateDir, projectRoot);
+  const dataFiles = await loadDataFilesInDir(templateDir, templateSource ?? "");
+  const hasLocalConfig = "config" in dataFiles;
+  const ctx = {
+    // Inherited helpers (can be overridden by data files with same name)
+    ...helpers,
+    // Auto-loaded data files
+    ...dataFiles,
+    // Config (only if no local config.* file)
+    ...hasLocalConfig ? {} : { config: options.config },
+    // Secrets
+    secrets: createSecretsProxy(options.secrets ?? {}),
+    globalSecrets: options.globalSecrets ?? {},
+    // Environment
+    env: process.env,
+    // Built-in helpers
+    include: createIncludeHelper(templateDir, projectRoot, options),
+    escape: sqlEscape,
+    quote: sqlQuote,
+    json: (value) => JSON.stringify(value),
+    now: isoNow,
+    uuid: generateUuid
+  };
+  return ctx;
+}
+function referencesContextKey(templateSource, key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `\\$\\s*(?:\\.\\s*${escaped}\\b|\\[\\s*(['"\`])${escaped}\\1\\s*\\])`
+  );
+  return pattern.test(templateSource);
+}
+async function loadDataFilesInDir(dir, templateSource) {
+  const data = {};
+  const [entries, readErr] = await attempt(() => readdir(dir, { withFileTypes: true }));
+  if (readErr || !entries) {
+    observer.emit("error", {
+      source: "template",
+      error: readErr ?? new Error("Failed to read directory"),
+      context: { dir, operation: "scan-data-files" }
+    });
+    return data;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (entry.name.startsWith(".") || entry.name.startsWith(HELPER_FILENAME)) {
+      continue;
+    }
+    if (entry.name.endsWith(".tmpl")) {
+      continue;
+    }
+    const ext = path__default.extname(entry.name).toLowerCase();
+    if (!hasLoader(ext)) {
+      continue;
+    }
+    if (ext === ".sql") {
+      continue;
+    }
+    const filepath = path__default.join(dir, entry.name);
+    const key = toContextKey(entry.name);
+    if (isExecutableExtension(ext) && !referencesContextKey(templateSource, key)) {
+      continue;
+    }
+    const [loaded, loadErr] = await attempt(() => loadDataFile(filepath));
+    if (loadErr) {
+      observer.emit("error", {
+        source: "template",
+        error: loadErr,
+        context: { filepath, operation: "load-data-file" }
+      });
+      continue;
+    }
+    data[key] = loaded;
+    observer.emit("template:load", {
+      filepath,
+      format: ext
+    });
+  }
+  return data;
+}
+function createIncludeHelper(templateDir, projectRoot, options) {
+  return async (includePath) => {
+    const resolved = path__default.resolve(templateDir, includePath);
+    if (!isWithinRoot(resolved, path__default.resolve(projectRoot))) {
+      throw new Error(`Include path escapes project root: ${includePath}`);
+    }
+    if (resolved.endsWith(".tmpl")) {
+      const { processFile: processFile2 } = await import('./engine-S4DX3V33.js');
+      const result = await processFile2(resolved, options);
+      return result.sql;
+    }
+    const [content, err] = await attempt(() => loadDataFile(resolved));
+    if (err) {
+      throw new Error(`Failed to include '${includePath}': ${err.message}`);
+    }
+    if (typeof content === "string") {
+      return content;
+    }
+    return JSON.stringify(content);
+  };
+}
+
+// src/core/template/engine.ts
+var DIRECTIVE_LINE_RE = /^[ \t]*-- (\{%.*?%\})[ \t]*$(?:\r?\n)?/gm;
+var eta = new Eta({
+  // Custom tags for code blocks
+  tags: ["{%", "%}"],
+  // Variable name for context ($ instead of it)
+  varName: "$",
+  // Don't auto-escape (SQL doesn't need HTML escaping)
+  autoEscape: false,
+  // Disabled — directive-line stripping handles whitespace instead
+  autoTrim: [false, false],
+  // Allow async functions in templates
+  useWith: false,
+  // Don't cache templates (we handle caching at a higher level)
+  cache: false
+});
+function isTemplate(filepath) {
+  return filepath.endsWith(TEMPLATE_EXTENSION);
+}
+async function renderTemplate(template, context) {
+  const prepared = template.replace(DIRECTIVE_LINE_RE, "$1");
+  const result = await eta.renderStringAsync(prepared, context);
+  return result.replace(/^\n+|\n+$/g, "");
+}
+async function processFile(filepath, options = {}) {
+  const content = await readFile$1(filepath, "utf-8");
+  if (!isTemplate(filepath)) {
+    return {
+      sql: content,
+      isTemplate: false
+    };
+  }
+  const start = performance.now();
+  const context = await buildContext(filepath, options);
+  const sql = await renderTemplate(content, context);
+  const durationMs = performance.now() - start;
+  observer.emit("template:render", {
+    filepath,
+    durationMs
+  });
+  return {
+    sql,
+    isTemplate: true,
+    durationMs
+  };
+}
+async function processFiles(filepaths, options = {}) {
+  const results = [];
+  for (const filepath of filepaths) {
+    const result = await processFile(filepath, options);
+    results.push(result);
+  }
+  return results;
+}
+/*! Bundled license information:
+
+voca/es/index.js:
+  (*! 
+   * Voca string library 1.4.1
+   * https://vocajs.pages.dev
+   *
+   * Copyright Dmitri Pavlutin and other contributors
+   * Released under the MIT license
+   *)
+*/
+
+export { DT_EXTENSIONS, DtReader, ENCODED_TYPES, FORMAT_VERSION, encryptWithPassphrase, es_default, eta, isTemplate, processFile, processFiles, renderTemplate };
+//# sourceMappingURL=chunk-DSXHOXDE.js.map
+//# sourceMappingURL=chunk-DSXHOXDE.js.map