@rhinostone/swig 2.7.2 → 2.8.0

package/dist/swig.runtime.js

@@ -0,0 +1,1519 @@
+/*! Swig v2.8.0 | https://github.com/gina-io/swig | @license https://github.com/gina-io/swig/blob/master/LICENSE */
+/*! DateZ (c) 2011 Tomo Universalis | @license https://github.com/tomoio/DateZ/blob/master/LISENCE */
+(() => {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+
+  // packages/swig-core/lib/security.js
+  var require_security = __commonJS({
+    "packages/swig-core/lib/security.js"(exports) {
+      exports.dangerousProps = ["__proto__", "constructor", "prototype"];
+    }
+  });
+
+  // packages/swig-core/lib/utils.js
+  var require_utils = __commonJS({
+    "packages/swig-core/lib/utils.js"(exports) {
+      var security = require_security();
+      var isArray;
+      exports.strip = function(input) {
+        return input.replace(/^\s+|\s+$/g, "");
+      };
+      exports.startsWith = function(str, prefix) {
+        return str.indexOf(prefix) === 0;
+      };
+      exports.endsWith = function(str, suffix) {
+        return str.indexOf(suffix, str.length - suffix.length) !== -1;
+      };
+      exports.each = function(obj, fn) {
+        var i, l;
+        if (isArray(obj)) {
+          i = 0;
+          l = obj.length;
+          for (i; i < l; i += 1) {
+            if (fn(obj[i], i, obj) === false) {
+              break;
+            }
+          }
+        } else {
+          for (i in obj) {
+            if (obj.hasOwnProperty(i)) {
+              if (fn(obj[i], i, obj) === false) {
+                break;
+              }
+            }
+          }
+        }
+        return obj;
+      };
+      exports.isArray = isArray = Array.hasOwnProperty("isArray") ? Array.isArray : function(obj) {
+        return obj ? typeof obj === "object" && Object.prototype.toString.call(obj).indexOf() !== -1 : false;
+      };
+      exports.some = function(obj, fn) {
+        var i = 0, result, l;
+        if (isArray(obj)) {
+          l = obj.length;
+          for (i; i < l; i += 1) {
+            result = fn(obj[i], i, obj);
+            if (result) {
+              break;
+            }
+          }
+        } else {
+          exports.each(obj, function(value, index) {
+            result = fn(value, index, obj);
+            return !result;
+          });
+        }
+        return !!result;
+      };
+      exports.map = function(obj, fn) {
+        var i = 0, result = [], l;
+        if (isArray(obj)) {
+          l = obj.length;
+          for (i; i < l; i += 1) {
+            result[i] = fn(obj[i], i);
+          }
+        } else {
+          for (i in obj) {
+            if (obj.hasOwnProperty(i)) {
+              result[i] = fn(obj[i], i);
+            }
+          }
+        }
+        return result;
+      };
+      exports.extend = function() {
+        var args = arguments, target = args[0], objs = args.length > 1 ? Array.prototype.slice.call(args, 1) : [], i = 0, l = objs.length, key, obj;
+        for (i; i < l; i += 1) {
+          obj = objs[i] || {};
+          for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+              target[key] = obj[key];
+            }
+          }
+        }
+        return target;
+      };
+      exports.keys = function(obj) {
+        if (!obj) {
+          return [];
+        }
+        if (Object.keys) {
+          return Object.keys(obj);
+        }
+        return exports.map(obj, function(v, k) {
+          return k;
+        });
+      };
+      exports.throwError = function(message, line, file) {
+        if (line) {
+          message += " on line " + line;
+        }
+        if (file) {
+          message += " in file " + file;
+        }
+        throw new Error(message + ".");
+      };
+      exports.range = function(from, to) {
+        var out = [], i, fc, tc;
+        if (typeof from === "number" && typeof to === "number") {
+          if (from <= to) {
+            for (i = from; i <= to; i += 1) {
+              out.push(i);
+            }
+          } else {
+            for (i = from; i >= to; i -= 1) {
+              out.push(i);
+            }
+          }
+          return out;
+        }
+        if (typeof from === "string" && typeof to === "string" && from.length === 1 && to.length === 1) {
+          fc = from.charCodeAt(0);
+          tc = to.charCodeAt(0);
+          if (fc <= tc) {
+            for (i = fc; i <= tc; i += 1) {
+              out.push(String.fromCharCode(i));
+            }
+          } else {
+            for (i = fc; i >= tc; i -= 1) {
+              out.push(String.fromCharCode(i));
+            }
+          }
+          return out;
+        }
+        return out;
+      };
+      exports.slice = function(obj, start, stop, step) {
+        var isString = typeof obj === "string", length, lower, upper, s, e, result = [], i;
+        function toInt(n) {
+          n = Number(n);
+          if (isNaN(n)) {
+            return NaN;
+          }
+          return n < 0 ? Math.ceil(n) : Math.floor(n);
+        }
+        function clamp(v, dflt) {
+          if (v === null || v === void 0) {
+            return dflt;
+          }
+          v = toInt(v);
+          if (isNaN(v)) {
+            return dflt;
+          }
+          if (v < 0) {
+            v += length;
+            if (v < lower) {
+              v = lower;
+            }
+          } else if (v > upper) {
+            v = upper;
+          }
+          return v;
+        }
+        if (obj === null || obj === void 0 || typeof obj.length !== "number") {
+          return isString ? "" : [];
+        }
+        length = obj.length;
+        if (step === null || step === void 0) {
+          step = 1;
+        } else {
+          step = toInt(step);
+          if (isNaN(step) || step === 0) {
+            step = 1;
+          }
+        }
+        if (step < 0) {
+          lower = -1;
+          upper = length - 1;
+        } else {
+          lower = 0;
+          upper = length;
+        }
+        s = clamp(start, step < 0 ? upper : lower);
+        e = clamp(stop, step < 0 ? lower : upper);
+        if (step > 0) {
+          for (i = s; i < e; i += step) {
+            result.push(obj[i]);
+          }
+        } else {
+          for (i = s; i > e; i += step) {
+            result.push(obj[i]);
+          }
+        }
+        return isString ? result.join("") : result;
+      };
+      exports.coerceOutput = function(v) {
+        return v === null || v === void 0 ? "" : v;
+      };
+      function resolveSeg(obj, seg) {
+        var val;
+        if (obj === null || obj === void 0) {
+          return void 0;
+        }
+        if (security.dangerousProps.indexOf(seg) !== -1) {
+          return void 0;
+        }
+        val = obj[seg];
+        if (typeof val === "function") {
+          if (val.alters_data === true) {
+            return void 0;
+          }
+          if (val.do_not_call_in_templates === true) {
+            return val;
+          }
+          try {
+            return val.call(obj);
+          } catch (e) {
+            return void 0;
+          }
+        }
+        return val;
+      }
+      exports.resolve = function(obj, path) {
+        var cur = obj, i;
+        for (i = 0; i < path.length; i += 1) {
+          cur = resolveSeg(cur, path[i]);
+          if (cur === null || cur === void 0) {
+            return cur;
+          }
+        }
+        return cur;
+      };
+    }
+  });
+
+  // packages/swig-core/lib/cache.js
+  var require_cache = __commonJS({
+    "packages/swig-core/lib/cache.js"(exports) {
+      exports.shouldCache = function(options, engineCache) {
+        options = options || {};
+        return options.hasOwnProperty("cache") && !options.cache || !engineCache;
+      };
+      exports.cacheGet = function(key, options, engineCache, memoryStore) {
+        if (exports.shouldCache(options, engineCache)) {
+          return;
+        }
+        if (engineCache === "memory") {
+          return Object.prototype.hasOwnProperty.call(memoryStore, key) ? memoryStore[key] : void 0;
+        }
+        return engineCache.get(key);
+      };
+      exports.cacheSet = function(key, options, val, engineCache, memoryStore) {
+        if (exports.shouldCache(options, engineCache)) {
+          return;
+        }
+        if (engineCache === "memory") {
+          memoryStore[key] = val;
+          return;
+        }
+        engineCache.set(key, val);
+      };
+    }
+  });
+
+  // node_modules/path-browserify/index.js
+  var require_path_browserify = __commonJS({
+    "node_modules/path-browserify/index.js"(exports, module) {
+      "use strict";
+      function assertPath(path) {
+        if (typeof path !== "string") {
+          throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
+        }
+      }
+      function normalizeStringPosix(path, allowAboveRoot) {
+        var res = "";
+        var lastSegmentLength = 0;
+        var lastSlash = -1;
+        var dots = 0;
+        var code;
+        for (var i = 0; i <= path.length; ++i) {
+          if (i < path.length)
+            code = path.charCodeAt(i);
+          else if (code === 47)
+            break;
+          else
+            code = 47;
+          if (code === 47) {
+            if (lastSlash === i - 1 || dots === 1) {
+            } else if (lastSlash !== i - 1 && dots === 2) {
+              if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+                if (res.length > 2) {
+                  var lastSlashIndex = res.lastIndexOf("/");
+                  if (lastSlashIndex !== res.length - 1) {
+                    if (lastSlashIndex === -1) {
+                      res = "";
+                      lastSegmentLength = 0;
+                    } else {
+                      res = res.slice(0, lastSlashIndex);
+                      lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                    }
+                    lastSlash = i;
+                    dots = 0;
+                    continue;
+                  }
+                } else if (res.length === 2 || res.length === 1) {
+                  res = "";
+                  lastSegmentLength = 0;
+                  lastSlash = i;
+                  dots = 0;
+                  continue;
+                }
+              }
+              if (allowAboveRoot) {
+                if (res.length > 0)
+                  res += "/..";
+                else
+                  res = "..";
+                lastSegmentLength = 2;
+              }
+            } else {
+              if (res.length > 0)
+                res += "/" + path.slice(lastSlash + 1, i);
+              else
+                res = path.slice(lastSlash + 1, i);
+              lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+          } else if (code === 46 && dots !== -1) {
+            ++dots;
+          } else {
+            dots = -1;
+          }
+        }
+        return res;
+      }
+      function _format(sep, pathObject) {
+        var dir = pathObject.dir || pathObject.root;
+        var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+        if (!dir) {
+          return base;
+        }
+        if (dir === pathObject.root) {
+          return dir + base;
+        }
+        return dir + sep + base;
+      }
+      var posix = {
+        // path.resolve([from ...], to)
+        resolve: function resolve() {
+          var resolvedPath = "";
+          var resolvedAbsolute = false;
+          var cwd;
+          for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+            var path;
+            if (i >= 0)
+              path = arguments[i];
+            else {
+              if (cwd === void 0)
+                cwd = process.cwd();
+              path = cwd;
+            }
+            assertPath(path);
+            if (path.length === 0) {
+              continue;
+            }
+            resolvedPath = path + "/" + resolvedPath;
+            resolvedAbsolute = path.charCodeAt(0) === 47;
+          }
+          resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+          if (resolvedAbsolute) {
+            if (resolvedPath.length > 0)
+              return "/" + resolvedPath;
+            else
+              return "/";
+          } else if (resolvedPath.length > 0) {
+            return resolvedPath;
+          } else {
+            return ".";
+          }
+        },
+        normalize: function normalize(path) {
+          assertPath(path);
+          if (path.length === 0) return ".";
+          var isAbsolute = path.charCodeAt(0) === 47;
+          var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+          path = normalizeStringPosix(path, !isAbsolute);
+          if (path.length === 0 && !isAbsolute) path = ".";
+          if (path.length > 0 && trailingSeparator) path += "/";
+          if (isAbsolute) return "/" + path;
+          return path;
+        },
+        isAbsolute: function isAbsolute(path) {
+          assertPath(path);
+          return path.length > 0 && path.charCodeAt(0) === 47;
+        },
+        join: function join() {
+          if (arguments.length === 0)
+            return ".";
+          var joined;
+          for (var i = 0; i < arguments.length; ++i) {
+            var arg = arguments[i];
+            assertPath(arg);
+            if (arg.length > 0) {
+              if (joined === void 0)
+                joined = arg;
+              else
+                joined += "/" + arg;
+            }
+          }
+          if (joined === void 0)
+            return ".";
+          return posix.normalize(joined);
+        },
+        relative: function relative(from, to) {
+          assertPath(from);
+          assertPath(to);
+          if (from === to) return "";
+          from = posix.resolve(from);
+          to = posix.resolve(to);
+          if (from === to) return "";
+          var fromStart = 1;
+          for (; fromStart < from.length; ++fromStart) {
+            if (from.charCodeAt(fromStart) !== 47)
+              break;
+          }
+          var fromEnd = from.length;
+          var fromLen = fromEnd - fromStart;
+          var toStart = 1;
+          for (; toStart < to.length; ++toStart) {
+            if (to.charCodeAt(toStart) !== 47)
+              break;
+          }
+          var toEnd = to.length;
+          var toLen = toEnd - toStart;
+          var length = fromLen < toLen ? fromLen : toLen;
+          var lastCommonSep = -1;
+          var i = 0;
+          for (; i <= length; ++i) {
+            if (i === length) {
+              if (toLen > length) {
+                if (to.charCodeAt(toStart + i) === 47) {
+                  return to.slice(toStart + i + 1);
+                } else if (i === 0) {
+                  return to.slice(toStart + i);
+                }
+              } else if (fromLen > length) {
+                if (from.charCodeAt(fromStart + i) === 47) {
+                  lastCommonSep = i;
+                } else if (i === 0) {
+                  lastCommonSep = 0;
+                }
+              }
+              break;
+            }
+            var fromCode = from.charCodeAt(fromStart + i);
+            var toCode = to.charCodeAt(toStart + i);
+            if (fromCode !== toCode)
+              break;
+            else if (fromCode === 47)
+              lastCommonSep = i;
+          }
+          var out = "";
+          for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+            if (i === fromEnd || from.charCodeAt(i) === 47) {
+              if (out.length === 0)
+                out += "..";
+              else
+                out += "/..";
+            }
+          }
+          if (out.length > 0)
+            return out + to.slice(toStart + lastCommonSep);
+          else {
+            toStart += lastCommonSep;
+            if (to.charCodeAt(toStart) === 47)
+              ++toStart;
+            return to.slice(toStart);
+          }
+        },
+        _makeLong: function _makeLong(path) {
+          return path;
+        },
+        dirname: function dirname(path) {
+          assertPath(path);
+          if (path.length === 0) return ".";
+          var code = path.charCodeAt(0);
+          var hasRoot = code === 47;
+          var end = -1;
+          var matchedSlash = true;
+          for (var i = path.length - 1; i >= 1; --i) {
+            code = path.charCodeAt(i);
+            if (code === 47) {
+              if (!matchedSlash) {
+                end = i;
+                break;
+              }
+            } else {
+              matchedSlash = false;
+            }
+          }
+          if (end === -1) return hasRoot ? "/" : ".";
+          if (hasRoot && end === 1) return "//";
+          return path.slice(0, end);
+        },
+        basename: function basename(path, ext) {
+          if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
+          assertPath(path);
+          var start = 0;
+          var end = -1;
+          var matchedSlash = true;
+          var i;
+          if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
+            if (ext.length === path.length && ext === path) return "";
+            var extIdx = ext.length - 1;
+            var firstNonSlashEnd = -1;
+            for (i = path.length - 1; i >= 0; --i) {
+              var code = path.charCodeAt(i);
+              if (code === 47) {
+                if (!matchedSlash) {
+                  start = i + 1;
+                  break;
+                }
+              } else {
+                if (firstNonSlashEnd === -1) {
+                  matchedSlash = false;
+                  firstNonSlashEnd = i + 1;
+                }
+                if (extIdx >= 0) {
+                  if (code === ext.charCodeAt(extIdx)) {
+                    if (--extIdx === -1) {
+                      end = i;
+                    }
+                  } else {
+                    extIdx = -1;
+                    end = firstNonSlashEnd;
+                  }
+                }
+              }
+            }
+            if (start === end) end = firstNonSlashEnd;
+            else if (end === -1) end = path.length;
+            return path.slice(start, end);
+          } else {
+            for (i = path.length - 1; i >= 0; --i) {
+              if (path.charCodeAt(i) === 47) {
+                if (!matchedSlash) {
+                  start = i + 1;
+                  break;
+                }
+              } else if (end === -1) {
+                matchedSlash = false;
+                end = i + 1;
+              }
+            }
+            if (end === -1) return "";
+            return path.slice(start, end);
+          }
+        },
+        extname: function extname(path) {
+          assertPath(path);
+          var startDot = -1;
+          var startPart = 0;
+          var end = -1;
+          var matchedSlash = true;
+          var preDotState = 0;
+          for (var i = path.length - 1; i >= 0; --i) {
+            var code = path.charCodeAt(i);
+            if (code === 47) {
+              if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+              }
+              continue;
+            }
+            if (end === -1) {
+              matchedSlash = false;
+              end = i + 1;
+            }
+            if (code === 46) {
+              if (startDot === -1)
+                startDot = i;
+              else if (preDotState !== 1)
+                preDotState = 1;
+            } else if (startDot !== -1) {
+              preDotState = -1;
+            }
+          }
+          if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+          preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+          preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+            return "";
+          }
+          return path.slice(startDot, end);
+        },
+        format: function format(pathObject) {
+          if (pathObject === null || typeof pathObject !== "object") {
+            throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+          }
+          return _format("/", pathObject);
+        },
+        parse: function parse(path) {
+          assertPath(path);
+          var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+          if (path.length === 0) return ret;
+          var code = path.charCodeAt(0);
+          var isAbsolute = code === 47;
+          var start;
+          if (isAbsolute) {
+            ret.root = "/";
+            start = 1;
+          } else {
+            start = 0;
+          }
+          var startDot = -1;
+          var startPart = 0;
+          var end = -1;
+          var matchedSlash = true;
+          var i = path.length - 1;
+          var preDotState = 0;
+          for (; i >= start; --i) {
+            code = path.charCodeAt(i);
+            if (code === 47) {
+              if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+              }
+              continue;
+            }
+            if (end === -1) {
+              matchedSlash = false;
+              end = i + 1;
+            }
+            if (code === 46) {
+              if (startDot === -1) startDot = i;
+              else if (preDotState !== 1) preDotState = 1;
+            } else if (startDot !== -1) {
+              preDotState = -1;
+            }
+          }
+          if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+          preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+          preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+            if (end !== -1) {
+              if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);
+              else ret.base = ret.name = path.slice(startPart, end);
+            }
+          } else {
+            if (startPart === 0 && isAbsolute) {
+              ret.name = path.slice(1, startDot);
+              ret.base = path.slice(1, end);
+            } else {
+              ret.name = path.slice(startPart, startDot);
+              ret.base = path.slice(startPart, end);
+            }
+            ret.ext = path.slice(startDot, end);
+          }
+          if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
+          else if (isAbsolute) ret.dir = "/";
+          return ret;
+        },
+        sep: "/",
+        delimiter: ":",
+        win32: null,
+        posix: null
+      };
+      posix.posix = posix;
+      module.exports = posix;
+    }
+  });
+
+  // packages/swig-core/lib/loaders/memory.js
+  var require_memory = __commonJS({
+    "packages/swig-core/lib/loaders/memory.js"(exports, module) {
+      var path = require_path_browserify();
+      var utils = require_utils();
+      module.exports = function(mapping, basepath) {
+        var ret = {};
+        basepath = basepath ? path.normalize(basepath) : null;
+        ret.resolve = function(to, from) {
+          if (basepath) {
+            if (/^\.\.([\\/]|$)/.test(path.normalize(to))) {
+              utils.throwError('Template "' + to + '" resolves outside the loader root "' + basepath + '".');
+            }
+            from = basepath;
+          } else {
+            from = from ? path.dirname(from) : "/";
+          }
+          return path.resolve(from, to);
+        };
+        ret.load = function(pathname, cb) {
+          var src, paths;
+          paths = [pathname, pathname.replace(/^(\/|\\)/, "")];
+          src = mapping[paths[0]] || mapping[paths[1]];
+          if (!src) {
+            utils.throwError('Unable to find template "' + pathname + '".');
+          }
+          if (cb) {
+            cb(null, src);
+            return;
+          }
+          return src;
+        };
+        return ret;
+      };
+    }
+  });
+
+  // packages/swig-core/lib/runtime.js
+  var require_runtime = __commonJS({
+    "packages/swig-core/lib/runtime.js"(exports) {
+      var utils = require_utils();
+      var cache = require_cache();
+      var memoryLoader = require_memory();
+      function efn() {
+        return "";
+      }
+      function noCompiler(what) {
+        return new Error(what + " \u2014 the runtime-only build has no compiler. Precompile with the swig CLI (swig compile --recursive --register) and register the output, or load the full swig bundle instead.");
+      }
+      exports.create = function(frontend) {
+        var filters = utils.extend({}, frontend.filters), self2 = {};
+        function validateRuntimeOptions(options) {
+          if (!options) {
+            return;
+          }
+          if (options.hasOwnProperty("loader") && options.loader) {
+            if (!options.loader.load || !options.loader.resolve) {
+              throw new Error("Invalid loader option " + JSON.stringify(options.loader) + " found. Expected { load: function (pathname, cb) { ... }, resolve: function (to, from) { ... } }.");
+            }
+          }
+          if (options.hasOwnProperty("cache") && options.cache && options.cache !== "memory") {
+            if (!options.cache.get || !options.cache.set) {
+              throw new Error("Invalid cache option " + JSON.stringify(options.cache) + ' found. Expected "memory" or { get: function (key) { ... }, set: function (key, value) { ... } }.');
+            }
+          }
+        }
+        validateRuntimeOptions(frontend.defaults);
+        self2.options = utils.extend({
+          autoescape: true,
+          locals: {},
+          cache: "memory",
+          loader: memoryLoader({}, "/")
+        }, frontend.defaults || {});
+        self2.cache = {};
+        self2.extensions = {};
+        function getLocals(options) {
+          if (!options || !options.locals) {
+            return self2.options.locals;
+          }
+          return utils.extend({}, self2.options.locals, options.locals);
+        }
+        function cacheGet(key, options) {
+          return cache.cacheGet(key, options, self2.options.cache, self2.cache);
+        }
+        function cacheSet(key, options, val) {
+          cache.cacheSet(key, options, val, self2.options.cache, self2.cache);
+        }
+        self2.setDefaults = function(options) {
+          validateRuntimeOptions(options);
+          self2.options = utils.extend(self2.options, options || {});
+        };
+        self2.invalidateCache = function() {
+          if (self2.options.cache === "memory") {
+            self2.cache = {};
+          }
+        };
+        self2.setFilter = function(name, method) {
+          if (typeof method !== "function") {
+            throw new Error('Filter "' + name + '" is not a valid function.');
+          }
+          filters[name] = method;
+        };
+        self2.setExtension = function(name, object) {
+          self2.extensions[name] = object;
+        };
+        function buildRegistered(fn) {
+          var context = getLocals(), contextLength = utils.keys(context).length;
+          return function registered(locals, blocks) {
+            var lcls;
+            if (locals && contextLength) {
+              lcls = utils.extend({}, context, locals);
+            } else if (locals && !contextLength) {
+              lcls = locals;
+            } else if (!locals && contextLength) {
+              lcls = context;
+            } else {
+              lcls = {};
+            }
+            return fn(self2, lcls, filters, utils, efn, blocks);
+          };
+        }
+        function validateRegistration(path, fn) {
+          if (typeof path !== "string" || !path.length) {
+            throw new Error("Template registration path must be a non-empty string.");
+          }
+          if (typeof fn !== "function") {
+            throw new Error('Registered template for "' + path + '" is not a function. Pass a pre-compiled template function.');
+          }
+          if (!self2.options.cache) {
+            throw new Error("Cannot register templates while caching is disabled (cache: " + self2.options.cache + "). The registry is the compile cache.");
+          }
+        }
+        self2.register = function(path, fn) {
+          validateRegistration(path, fn);
+          cacheSet(self2.options.loader.resolve(path), {}, buildRegistered(fn));
+          return self2;
+        };
+        self2.registerBundle = function(map) {
+          var entries = [];
+          if (!map || typeof map !== "object") {
+            throw new Error("Template bundle must be an object of { path: templateFn } pairs.");
+          }
+          utils.each(map, function(fn, path) {
+            entries.push([path, fn]);
+            validateRegistration(path, fn);
+          });
+          utils.each(entries, function(entry) {
+            self2.register(entry[0], entry[1]);
+          });
+          return self2;
+        };
+        self2.run = function(tpl, locals, filepath) {
+          var context = getLocals({ locals });
+          if (filepath) {
+            cacheSet(self2.options.loader.resolve(filepath), {}, buildRegistered(tpl));
+          }
+          return tpl(self2, context, filters, utils, efn);
+        };
+        self2.compileFile = function(pathname, options, cb) {
+          var resolved, cached, err;
+          if (!options) {
+            options = {};
+          }
+          resolved = self2.options.loader.resolve(pathname, options.resolveFrom);
+          cached = cacheGet(resolved, options);
+          if (cached) {
+            if (cb) {
+              cb(null, cached);
+              return;
+            }
+            return cached;
+          }
+          err = noCompiler('Template "' + pathname + '" is not registered');
+          if (cb) {
+            cb(err);
+            return;
+          }
+          throw err;
+        };
+        self2.renderFile = function(pathName, locals, cb) {
+          if (cb) {
+            self2.compileFile(pathName, {}, function(err, fn) {
+              var result;
+              if (err) {
+                cb(err);
+                return;
+              }
+              try {
+                result = fn(locals);
+              } catch (err2) {
+                cb(err2);
+                return;
+              }
+              cb(null, result);
+            });
+            return;
+          }
+          return self2.compileFile(pathName)(locals);
+        };
+        self2.getTemplate = function(pathname) {
+          return Promise.reject(noCompiler('Async template loading of "' + pathname + '" is unavailable'));
+        };
+        self2.parse = function() {
+          throw noCompiler("parse() is unavailable");
+        };
+        self2.parseFile = function() {
+          throw noCompiler("parseFile() is unavailable");
+        };
+        self2.precompile = function() {
+          throw noCompiler("precompile() is unavailable");
+        };
+        self2.compile = function() {
+          throw noCompiler("compile() is unavailable");
+        };
+        self2.render = function() {
+          throw noCompiler("render(source) is unavailable");
+        };
+        self2.setTag = function() {
+          throw noCompiler("setTag() is parse-time machinery and is unavailable");
+        };
+        self2.renderFileAsync = function() {
+          throw noCompiler("renderFileAsync() is unavailable");
+        };
+        self2.compileFileAsync = function() {
+          throw noCompiler("compileFileAsync() is unavailable");
+        };
+        return self2;
+      };
+    }
+  });
+
+  // lib/utils.js
+  var require_utils2 = __commonJS({
+    "lib/utils.js"(exports, module) {
+      module.exports = require_utils();
+    }
+  });
+
+  // packages/swig-core/lib/dateformatter.js
+  var require_dateformatter = __commonJS({
+    "packages/swig-core/lib/dateformatter.js"(exports) {
+      var utils = require_utils();
+      var _months = {
+        full: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+        abbr: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+      };
+      var _days = {
+        full: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+        abbr: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+        alt: { "-1": "Yesterday", 0: "Today", 1: "Tomorrow" }
+      };
+      exports.tzOffset = 0;
+      exports.DateZ = function() {
+        var members = {
+          "default": ["getUTCDate", "getUTCDay", "getUTCFullYear", "getUTCHours", "getUTCMilliseconds", "getUTCMinutes", "getUTCMonth", "getUTCSeconds", "toISOString", "toGMTString", "toUTCString", "valueOf", "getTime"],
+          z: ["getDate", "getDay", "getFullYear", "getHours", "getMilliseconds", "getMinutes", "getMonth", "getSeconds", "getYear", "toDateString", "toLocaleDateString", "toLocaleTimeString"]
+        }, d = this;
+        d.date = d.dateZ = arguments.length > 1 ? new Date(Date.UTC.apply(Date, arguments) + (/* @__PURE__ */ new Date()).getTimezoneOffset() * 6e4) : arguments.length === 1 ? new Date(new Date(arguments["0"])) : /* @__PURE__ */ new Date();
+        d.timezoneOffset = d.dateZ.getTimezoneOffset();
+        utils.each(members.z, function(name) {
+          d[name] = function() {
+            return d.dateZ[name]();
+          };
+        });
+        utils.each(members["default"], function(name) {
+          d[name] = function() {
+            return d.date[name]();
+          };
+        });
+        this.setTimezoneOffset(exports.tzOffset);
+      };
+      exports.DateZ.prototype = {
+        getTimezoneOffset: function() {
+          return this.timezoneOffset;
+        },
+        setTimezoneOffset: function(offset) {
+          this.timezoneOffset = offset;
+          this.dateZ = new Date(this.date.getTime() + this.date.getTimezoneOffset() * 6e4 - this.timezoneOffset * 6e4);
+          return this;
+        }
+      };
+      exports.d = function(input) {
+        return (input.getDate() < 10 ? "0" : "") + input.getDate();
+      };
+      exports.D = function(input) {
+        return _days.abbr[input.getDay()];
+      };
+      exports.j = function(input) {
+        return input.getDate();
+      };
+      exports.l = function(input) {
+        return _days.full[input.getDay()];
+      };
+      exports.N = function(input) {
+        var d = input.getDay();
+        return d >= 1 ? d : 7;
+      };
+      exports.S = function(input) {
+        var d = input.getDate();
+        return d % 10 === 1 && d !== 11 ? "st" : d % 10 === 2 && d !== 12 ? "nd" : d % 10 === 3 && d !== 13 ? "rd" : "th";
+      };
+      exports.w = function(input) {
+        return input.getDay();
+      };
+      exports.z = function(input, offset, abbr) {
+        var year = input.getFullYear(), e = new exports.DateZ(year, input.getMonth(), input.getDate(), 12, 0, 0), d = new exports.DateZ(year, 0, 1, 12, 0, 0);
+        e.setTimezoneOffset(offset, abbr);
+        d.setTimezoneOffset(offset, abbr);
+        return Math.round((e - d) / 864e5);
+      };
+      exports.W = function(input) {
+        var target = new Date(input.valueOf()), dayNr = (input.getDay() + 6) % 7, fThurs;
+        target.setDate(target.getDate() - dayNr + 3);
+        fThurs = target.valueOf();
+        target.setMonth(0, 1);
+        if (target.getDay() !== 4) {
+          target.setMonth(0, 1 + (4 - target.getDay() + 7) % 7);
+        }
+        return 1 + Math.ceil((fThurs - target) / 6048e5);
+      };
+      exports.F = function(input) {
+        return _months.full[input.getMonth()];
+      };
+      exports.m = function(input) {
+        return (input.getMonth() < 9 ? "0" : "") + (input.getMonth() + 1);
+      };
+      exports.M = function(input) {
+        return _months.abbr[input.getMonth()];
+      };
+      exports.n = function(input) {
+        return input.getMonth() + 1;
+      };
+      exports.t = function(input) {
+        return 32 - new Date(input.getFullYear(), input.getMonth(), 32).getDate();
+      };
+      exports.L = function(input) {
+        return new Date(input.getFullYear(), 1, 29).getDate() === 29;
+      };
+      exports.o = function(input) {
+        var target = new Date(input.valueOf());
+        target.setDate(target.getDate() - (input.getDay() + 6) % 7 + 3);
+        return target.getFullYear();
+      };
+      exports.Y = function(input) {
+        return input.getFullYear();
+      };
+      exports.y = function(input) {
+        return input.getFullYear().toString().substr(2);
+      };
+      exports.a = function(input) {
+        return input.getHours() < 12 ? "am" : "pm";
+      };
+      exports.A = function(input) {
+        return input.getHours() < 12 ? "AM" : "PM";
+      };
+      exports.B = function(input) {
+        var hours = input.getUTCHours(), beats;
+        hours = hours === 23 ? 0 : hours + 1;
+        beats = Math.abs(((hours * 60 + input.getUTCMinutes()) * 60 + input.getUTCSeconds()) / 86.4).toFixed(0);
+        return "000".concat(beats).slice(beats.length);
+      };
+      exports.g = function(input) {
+        var h = input.getHours();
+        return h === 0 ? 12 : h > 12 ? h - 12 : h;
+      };
+      exports.G = function(input) {
+        return input.getHours();
+      };
+      exports.h = function(input) {
+        var h = input.getHours();
+        return (h < 10 || 12 < h && 22 > h ? "0" : "") + (h < 12 ? h : h - 12);
+      };
+      exports.H = function(input) {
+        var h = input.getHours();
+        return (h < 10 ? "0" : "") + h;
+      };
+      exports.i = function(input) {
+        var m = input.getMinutes();
+        return (m < 10 ? "0" : "") + m;
+      };
+      exports.s = function(input) {
+        var s = input.getSeconds();
+        return (s < 10 ? "0" : "") + s;
+      };
+      exports.O = function(input) {
+        var tz = input.getTimezoneOffset();
+        return (tz < 0 ? "-" : "+") + (tz / 60 < 10 ? "0" : "") + Math.abs(tz / 60) + "00";
+      };
+      exports.Z = function(input) {
+        return input.getTimezoneOffset() * 60;
+      };
+      exports.c = function(input) {
+        return input.toISOString();
+      };
+      exports.r = function(input) {
+        return input.toUTCString();
+      };
+      exports.U = function(input) {
+        return input.getTime() / 1e3;
+      };
+    }
+  });
+
+  // lib/dateformatter.js
+  var require_dateformatter2 = __commonJS({
+    "lib/dateformatter.js"(exports, module) {
+      module.exports = require_dateformatter();
+    }
+  });
+
+  // packages/swig-core/lib/filters.js
+  var require_filters = __commonJS({
+    "packages/swig-core/lib/filters.js"(exports) {
+      var utils = require_utils();
+      exports.iterateFilter = function iterateFilter(input) {
+        var self2 = this, out = {};
+        if (utils.isArray(input)) {
+          return utils.map(input, function(value) {
+            return self2.apply(null, arguments);
+          });
+        }
+        if (typeof input === "object") {
+          utils.each(input, function(value, key) {
+            out[key] = self2.apply(null, arguments);
+          });
+          return out;
+        }
+        return;
+      };
+    }
+  });
+
+  // lib/filters.js
+  var require_filters2 = __commonJS({
+    "lib/filters.js"(exports) {
+      var utils = require_utils2();
+      var dateFormatter = require_dateformatter2();
+      var iterateFilter = require_filters().iterateFilter;
+      exports.addslashes = function(input) {
+        var out = iterateFilter.apply(exports.addslashes, arguments);
+        if (out !== void 0) {
+          return out;
+        }
+        return input.replace(/\\/g, "\\\\").replace(/\'/g, "\\'").replace(/\"/g, '\\"');
+      };
+      exports.capitalize = function(input) {
+        var out = iterateFilter.apply(exports.capitalize, arguments);
+        if (out !== void 0) {
+          return out;
+        }
+        return input.toString().charAt(0).toUpperCase() + input.toString().substr(1).toLowerCase();
+      };
+      exports.date = function(input, format, offset, abbr) {
+        var l = format.length, date = new dateFormatter.DateZ(input), cur, i = 0, out = "";
+        if (offset) {
+          date.setTimezoneOffset(offset, abbr);
+        }
+        for (i; i < l; i += 1) {
+          cur = format.charAt(i);
+          if (cur === "\\") {
+            i += 1;
+            out += i < l ? format.charAt(i) : cur;
+          } else if (dateFormatter.hasOwnProperty(cur)) {
+            out += dateFormatter[cur](date, offset, abbr);
+          } else {
+            out += cur;
+          }
+        }
+        return out;
+      };
+      exports["default"] = function(input, def) {
+        return typeof input !== "undefined" && (input || typeof input === "number") ? input : def;
+      };
+      function escapeHtmlRest(ch) {
+        return ch === "<" ? "&lt;" : ch === ">" ? "&gt;" : ch === '"' ? "&quot;" : "&#39;";
+      }
+      exports.escape = function(input, type) {
+        var t, inp, out, i, code;
+        if (input === null || input === void 0) {
+          return input;
+        }
+        t = typeof input;
+        if (t !== "string") {
+          if (t === "object") {
+            out = iterateFilter.apply(exports.escape, arguments);
+            if (out !== void 0) {
+              return out;
+            }
+          }
+          return input;
+        }
+        if (type === "js") {
+          inp = input.replace(/\\/g, "\\u005C");
+          out = "";
+          for (i = 0; i < inp.length; i += 1) {
+            code = inp.charCodeAt(i);
+            if (code < 32) {
+              code = code.toString(16).toUpperCase();
+              code = code.length < 2 ? "0" + code : code;
+              out += "\\u00" + code;
+            } else {
+              out += inp[i];
+            }
+          }
+          return out.replace(/&/g, "\\u0026").replace(/</g, "\\u003C").replace(/>/g, "\\u003E").replace(/\'/g, "\\u0027").replace(/"/g, "\\u0022").replace(/\=/g, "\\u003D").replace(/-/g, "\\u002D").replace(/;/g, "\\u003B");
+        }
+        return input.replace(/&(?!amp;|lt;|gt;|quot;|#39;)/g, "&amp;").replace(/[<>"']/g, escapeHtmlRest);
+      };
+      exports.e = exports.escape;
+      exports.first = function(input) {
+        if (typeof input === "object" && !utils.isArray(input)) {
+          var keys = utils.keys(input);
+          return input[keys[0]];
+        }
+        if (typeof input === "string") {
+          return input.substr(0, 1);
+        }
+        return input[0];
+      };
+      exports.groupBy = function(input, key) {
+        if (!utils.isArray(input)) {
+          return input;
+        }
+        var out = {};
+        utils.each(input, function(value) {
+          if (!value.hasOwnProperty(key)) {
+            return;
+          }
+          var keyname = value[key], newValue = utils.extend({}, value);
+          delete newValue[key];
+          if (!out[keyname]) {
+            out[keyname] = [];
+          }
+          out[keyname].push(newValue);
+        });
+        return out;
+      };
+      exports.join = function(input, glue) {
+        if (utils.isArray(input)) {
+          return input.join(glue);
+        }
+        if (typeof input === "object") {
+          var out = [];
+          utils.each(input, function(value) {
+            out.push(value);
+          });
+          return out.join(glue);
+        }
+        return input;
+      };
+      exports.json = function(input, indent) {
+        var json = JSON.stringify(input, null, indent || 0);
+        if (typeof json !== "string") {
+          return json;
+        }
+        return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/'/g, "\\u0027");
+      };
+      exports.json.safe = true;
+      exports.json_encode = exports.json;
+      exports.last = function(input) {
+        if (typeof input === "object" && !utils.isArray(input)) {
+          var keys = utils.keys(input);
+          return input[keys[keys.length - 1]];
+        }
+        if (typeof input === "string") {
+          return input.charAt(input.length - 1);
+        }
+        return input[input.length - 1];
+      };
+      exports.length = function(input) {
+        if (typeof input === "object" && !utils.isArray(input)) {
+          var keys = utils.keys(input);
+          return keys.length;
+        }
+        if (input.hasOwnProperty("length")) {
+          return input.length;
+        }
+        return "";
+      };
+      exports.lower = function(input) {
+        var out = iterateFilter.apply(exports.lower, arguments);
+        if (out !== void 0) {
+          return out;
+        }
+        return input.toString().toLowerCase();
+      };
+      exports.raw = function(input) {
+        return exports.safe(input);
+      };
+      exports.raw.safe = true;
+      exports.replace = function(input, search, replacement, flags) {
+        var r = new RegExp(search, flags);
+        return input.replace(r, replacement);
+      };
+      exports.reverse = function(input) {
+        return exports.sort(input, true);
+      };
+      exports.safe = function(input) {
+        return input;
+      };
+      exports.safe.safe = true;
+      exports.sort = function(input, reverse) {
+        var out, clone;
+        if (utils.isArray(input)) {
+          clone = utils.extend([], input);
+          out = clone.sort();
+        } else {
+          switch (typeof input) {
+            case "object":
+              out = utils.keys(input).sort();
+              break;
+            case "string":
+              out = input.split("");
+              if (reverse) {
+                return out.reverse().join("");
+              }
+              return out.sort().join("");
+          }
+        }
+        if (out && reverse) {
+          return out.reverse();
+        }
+        return out || input;
+      };
+      exports.striptags = function(input) {
+        var out = iterateFilter.apply(exports.striptags, arguments);
+        if (out !== void 0) {
+          return out;
+        }
+        return input.toString().replace(/(<([^>]+)>)/ig, "");
+      };
+      exports.title = function(input) {
+        var out = iterateFilter.apply(exports.title, arguments);
+        if (out !== void 0) {
+          return out;
+        }
+        return input.toString().replace(/\w\S*/g, function(str) {
+          return str.charAt(0).toUpperCase() + str.substr(1).toLowerCase();
+        });
+      };
+      exports.uniq = function(input) {
+        var result;
+        if (!input || !utils.isArray(input)) {
+          return "";
+        }
+        result = [];
+        utils.each(input, function(v) {
+          if (result.indexOf(v) === -1) {
+            result.push(v);
+          }
+        });
+        return result;
+      };
+      exports.upper = function(input) {
+        var out = iterateFilter.apply(exports.upper, arguments);
+        if (out !== void 0) {
+          return out;
+        }
+        return input.toString().toUpperCase();
+      };
+      exports.url_encode = function(input) {
+        var out = iterateFilter.apply(exports.url_encode, arguments);
+        if (out !== void 0) {
+          return out;
+        }
+        return encodeURIComponent(input);
+      };
+      exports.url_encode.safe = true;
+      exports.url_decode = function(input) {
+        var out = iterateFilter.apply(exports.url_decode, arguments);
+        if (out !== void 0) {
+          return out;
+        }
+        return decodeURIComponent(input);
+      };
+    }
+  });
+
+  // browser/stubs/fs.js
+  var require_fs = __commonJS({
+    "browser/stubs/fs.js"(exports, module) {
+      module.exports = {};
+    }
+  });
+
+  // packages/swig-core/lib/loaders/filesystem.js
+  var require_filesystem = __commonJS({
+    "packages/swig-core/lib/loaders/filesystem.js"(exports, module) {
+      var fs = require_fs();
+      var path = require_path_browserify();
+      module.exports = function(basepath, encoding, allowOutsideRoot) {
+        var ret = {};
+        encoding = encoding || "utf8";
+        basepath = basepath ? path.resolve(basepath) : null;
+        ret.resolve = function(to, from) {
+          var resolved, rootWithSep;
+          if (basepath) {
+            from = basepath;
+          } else {
+            from = from ? path.dirname(from) : process.cwd();
+          }
+          resolved = path.resolve(from, to);
+          if (basepath && !allowOutsideRoot) {
+            rootWithSep = path.normalize(basepath + path.sep);
+            if (resolved !== basepath && resolved.indexOf(rootWithSep) !== 0) {
+              throw new Error('Template "' + to + '" resolves outside the loader root "' + basepath + '" (CVE-2023-25345).');
+            }
+          }
+          return resolved;
+        };
+        ret.load = function(identifier, cb) {
+          if (!fs || cb && !fs.readFile || !fs.readFileSync) {
+            throw new Error("Unable to find file " + identifier + " because there is no filesystem to read from.");
+          }
+          identifier = ret.resolve(identifier);
+          if (cb) {
+            fs.readFile(identifier, encoding, cb);
+            return;
+          }
+          return fs.readFileSync(identifier, encoding);
+        };
+        return ret;
+      };
+    }
+  });
+
+  // packages/swig-core/lib/loaders/index.js
+  var require_loaders = __commonJS({
+    "packages/swig-core/lib/loaders/index.js"(exports) {
+      exports.fs = require_filesystem();
+      exports.memory = require_memory();
+    }
+  });
+
+  // lib/loaders/index.js
+  var require_loaders2 = __commonJS({
+    "lib/loaders/index.js"(exports, module) {
+      module.exports = require_loaders();
+    }
+  });
+
+  // lib/runtime.js
+  var require_runtime2 = __commonJS({
+    "lib/runtime.js"(exports) {
+      var runtime = require_runtime();
+      var _filters = require_filters2();
+      var dateformatter = require_dateformatter2();
+      var loaders = require_loaders2();
+      exports.version = "2.8.0";
+      var defaultInstance = runtime.create({ filters: _filters });
+      exports.Swig = function(opts) {
+        return runtime.create({ filters: _filters, defaults: opts });
+      };
+      exports.loaders = loaders;
+      exports.register = defaultInstance.register;
+      exports.registerBundle = defaultInstance.registerBundle;
+      exports.run = defaultInstance.run;
+      exports.compileFile = defaultInstance.compileFile;
+      exports.renderFile = defaultInstance.renderFile;
+      exports.setFilter = defaultInstance.setFilter;
+      exports.setExtension = defaultInstance.setExtension;
+      exports.setDefaults = defaultInstance.setDefaults;
+      exports.invalidateCache = defaultInstance.invalidateCache;
+      exports.setDefaultTZOffset = function(offset) {
+        dateformatter.tzOffset = offset;
+      };
+      exports.parse = defaultInstance.parse;
+      exports.parseFile = defaultInstance.parseFile;
+      exports.precompile = defaultInstance.precompile;
+      exports.compile = defaultInstance.compile;
+      exports.render = defaultInstance.render;
+      exports.setTag = defaultInstance.setTag;
+      exports.renderFileAsync = defaultInstance.renderFileAsync;
+      exports.compileFileAsync = defaultInstance.compileFileAsync;
+    }
+  });
+
+  // browser/runtime.js
+  var require_runtime3 = __commonJS({
+    "browser/runtime.js"(exports) {
+      var swig = require_runtime2();
+      var root = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : exports;
+      if (typeof root.define === "function" && typeof root.define.amd === "object") {
+        root.define("swig", [], function() {
+          return swig;
+        });
+      }
+      if (!root.swig) {
+        root.swig = swig;
+      }
+    }
+  });
+  require_runtime3();
+})();
+/*!
+ * Resolve a single path segment against a value, Django-style. A plain
+ * property access (`obj[seg]`) covers dictionary, attribute, and array /
+ * string index lookup in one step (JS string-keys an array / string by a
+ * numeric segment, so `["a"][0]` and `["a"]["0"]` both yield the element).
+ * A callable leaf is auto-called with no arguments, bound to its receiver,
+ * honoring Django's opt-outs: `fn.alters_data === true` is not called and
+ * yields `undefined` (Django renders nothing for data-altering callables);
+ * `fn.do_not_call_in_templates === true` is returned uncalled. A call that
+ * throws (e.g. a method that needs arguments) yields `undefined`, mirroring
+ * Django's `string_if_invalid` fallback on a failed auto-call. The
+ * `_dangerousProps` segments are rejected at runtime as defense-in-depth.
+ * @private
+ */
+/*!
+ * Empty function used as a fallback in compiled template code.
+ */
+/*!
+ * Build the error every unavailable compiling entry point throws.
+ */
+/*!
+ * Wrap a pre-compiled template function in the locals-binding call shape
+ * cached entries have, mirroring the engine.
+ * @private
+ */
+/*!
+ * Shared argument checks for register / registerBundle, so a bundle is
+ * validated in full before any entry is committed.
+ * @private
+ */
+/*!
+ * Default runtime instance backing the module-level exports.
+ */
+/*!
+ * Export methods publicly via the default instance.
+ */
+/*!
+ * Compiling entry points stay on the module surface as clear-error
+ * stubs, so a drop-in swap from the full build fails with the
+ * no-compiler explanation instead of a bare TypeError.
+ */