@nextrush/router 4.0.0-beta.0 → 4.0.0-beta.1

package/dist/index.d.ts

@@ -106,6 +106,13 @@ declare class Router {
     private hasParamRoutes;
     /** Whether router-level middleware has already been sealed into executors (audit RT-7) */
     private _sealed;
+    /**
+     * Single-entry memo for {@link matchesMountPrefix}'s canonicalization of the
+     * mount prefix, which is fixed at registration time. Declared as two fields
+     * rather than an object so a miss stores without allocating.
+     */
+    private _prefixMemoRaw;
+    private _prefixMemoCanonical;
     /** Memoized state the extracted registration/matching functions read (see {@link createRouterState}). */
     private readonly state;
     constructor(options?: RouterOptions);
@@ -149,6 +156,21 @@ declare class Router {
     private mountRouter;
     /** Match a request to a route — delegates to {@link resolveMatch} (design.md D1). */
     match(method: HttpMethod, path: string): RouteMatch | null;
+    /**
+     * Test whether `path` falls under `prefix` using this router's OWN
+     * canonicalization (case folding per `caseSensitive`, structural
+     * normalization) — the mount-boundary counterpart to {@link match}, so a
+     * router mounted via `Application.route()` is tested with the identical
+     * rule it dispatches with (RFC-029, task 3.8). Implements the optional
+     * `Routable.matchesMountPrefix` contract from `@nextrush/core`.
+     *
+     * @param path - The full request path being tested for this mount.
+     * @param prefix - The normalized mount prefix (leading `/`, no trailing `/`).
+     * @returns The path's remainder past the prefix (e.g. `/users` for a
+     *   `/ADMIN/Users` request mounted at `/admin`), or `undefined` when `path`
+     *   is not under `prefix` per this router's canonicalization.
+     */
+    matchesMountPrefix(path: string, prefix: string): string | undefined;
     /**
      * Return the router's dispatch middleware — mount this on the application.
      * @see {@link https://github.com/0xTanzim/nextRush/blob/main/packages/router/README.md#routerroutes | README: router.routes()}
@@ -184,6 +206,68 @@ declare class Router {
  */
 declare function createRouter(options?: RouterOptions): Router;
 
+/**
+ * @nextrush/router - Canonical Request Path
+ *
+ * The single normalization owner (RFC-029): every consumer that needs to know
+ * "what path does the router treat this request as" — the router's own match,
+ * a mounted-router prefix test, a CSRF exclude-path match, an adapter's
+ * published `ctx.path` — calls {@link canonicalizePath} instead of hand-rolling
+ * its own fold/collapse/strip, so there is exactly one definition of "the same
+ * path" across the framework (SEC-02, SEC-09, SEC-15).
+ *
+ * @see docs/RFC/request-data/029-canonical-request-path.md
+ * @packageDocumentation
+ */
+/** Result of {@link canonicalizePath}. */
+interface CanonicalPathResult {
+    /**
+     * `true` when the path contains a `.`/`..` path segment. A dot segment is
+     * rejected outright (400), never resolved — resolving it locally would
+     * diverge from how a front-end proxy already resolved (or didn't resolve)
+     * the same segment before forwarding, reopening the desync this RFC closes.
+     */
+    readonly rejected: boolean;
+    /**
+     * The canonical path: query-stripped, dot-segment-free, case-folded (unless
+     * `caseSensitive`), slash-collapsed, trailing-slash-stripped per `strict`.
+     * Meaningless when {@link rejected} is `true`.
+     */
+    readonly path: string;
+}
+/**
+ * True when `path` (already query-stripped) contains a `.` or `..` segment —
+ * a component that is exactly `.` or `..` between slash boundaries (or at the
+ * start/end of the string). A single linear scan, no backtracking regex
+ * (task 3.5): each character is visited at most once, so a pathological input
+ * cannot degrade to worse than O(n).
+ *
+ * A dot as filename content (`archive.tar.gz`, `..hidden.txt`) is NOT a dot
+ * segment — only a component whose entire text between slashes is `.` or `..`
+ * counts.
+ */
+declare function hasDotSegment(path: string): boolean;
+/**
+ * Canonicalize a raw request target into the one path value every consumer
+ * (router match, mount-prefix test, CSRF exclude match, published `ctx.path`)
+ * treats as "this request's path" (RFC-029).
+ *
+ * Order: strip the query string, reject a dot segment before any further
+ * normalization (a dot segment is a request-shape violation, not something to
+ * fold case on first), then fold case (unless `caseSensitive`) and collapse
+ * structure exactly as {@link import('./matching').normalizePathForMatch} does
+ * — this function IS that normalization, extended with dot-segment rejection
+ * and made a public, adapter-facing entry point.
+ *
+ * The most recent result is memoized; see the note above the memo fields for
+ * why that is sound. Treat the returned object as immutable.
+ *
+ * @param rawTarget - The raw request target, may include a query string.
+ * @param caseSensitive - Router case-sensitivity option.
+ * @param strict - Router strict-trailing-slash option.
+ */
+declare function canonicalizePath(rawTarget: string, caseSensitive: boolean, strict: boolean): CanonicalPathResult;
+
 /**
  * @nextrush/router - Segment Trie Node
  *
@@ -233,6 +317,14 @@ interface HandlerEntry {
     middleware: Middleware[];
     /** Pre-compiled executor for fast dispatch (no closure per request) */
     executor?: (ctx: Context) => Promise<void>;
+    /**
+     * `true` only for a `HEAD` entry derived from a `GET` registration
+     * (RFC 9110 §9.3.2). A derived entry is replaced by an explicit `HEAD`
+     * registration instead of reporting a route conflict, is absent from
+     * `getRoutes()`, and is skipped when copying routes into a parent router —
+     * which re-derives it from the `GET` it copies.
+     */
+    autoHead: boolean;
 }
 /**
  * Create a new segment trie node
@@ -255,4 +347,4 @@ interface ParsedSegment {
     paramName?: string;
 }
 
-export { type HandlerEntry, NodeType, type ParsedSegment, type RouteGroup, Router, type TrieNode, createNode, createRouter, endpoint, parseSegments };
+export { type CanonicalPathResult, type HandlerEntry, NodeType, type ParsedSegment, type RouteGroup, Router, type TrieNode, canonicalizePath, createNode, createRouter, endpoint, hasDotSegment, parseSegments };

package/dist/index.js

@@ -271,7 +271,130 @@ function runRouteGroup(host, prefix, middlewareOrCallback, callback, inheritedMi
 __name(runRouteGroup, "runRouteGroup");
 
 // src/constants.ts
-var EMPTY_PARAMS = Object.freeze(/* @__PURE__ */ Object.create(null));
+var NULL_PROTO = /* @__PURE__ */ Object.create(null);
+var EMPTY_PARAMS = Object.freeze(Object.create(NULL_PROTO));
+
+// src/walk-pool.ts
+function createWalkPool(maxDepth) {
+  const frames = [];
+  for (let i = 0; i < maxDepth + 1; i++) {
+    frames.push({
+      node: void 0,
+      pos: 0,
+      stage: 0,
+      seg: "",
+      next: 0,
+      bound: false
+    });
+  }
+  return {
+    frames,
+    bindNames: [],
+    bindValues: []
+  };
+}
+__name(createWalkPool, "createWalkPool");
+function matchNodeIndexedPooled(root, path, startPos, bindNames, bindValues, method, decode, pool, originalPath) {
+  const { frames } = pool;
+  let depth = 0;
+  const first = frames[0];
+  if (first === void 0) return null;
+  first.node = root;
+  first.pos = startPos;
+  first.stage = 0;
+  first.seg = "";
+  first.next = 0;
+  first.bound = false;
+  while (depth >= 0) {
+    const frame = frames[depth];
+    if (frame === void 0) break;
+    if (frame.stage === 0) {
+      if (frame.pos >= path.length) {
+        const handler = frame.node.handlers.get(method);
+        if (handler) return handler;
+        depth--;
+        continue;
+      }
+      const slashPos = path.indexOf("/", frame.pos);
+      if (slashPos === -1) {
+        frame.seg = path.slice(frame.pos);
+        frame.next = path.length;
+      } else {
+        frame.seg = path.slice(frame.pos, slashPos);
+        frame.next = slashPos + 1;
+      }
+      if (frame.seg === "") {
+        const handler = frame.node.handlers.get(method);
+        if (handler) return handler;
+        depth--;
+        continue;
+      }
+      frame.stage = 1;
+      const staticChild = frame.node.children.get(frame.seg);
+      if (staticChild) {
+        depth++;
+        const next = frames[depth];
+        if (next === void 0) {
+          depth--;
+          continue;
+        }
+        next.node = staticChild;
+        next.pos = frame.next;
+        next.stage = 0;
+        next.seg = "";
+        next.next = 0;
+        next.bound = false;
+      }
+      continue;
+    }
+    if (frame.stage === 1) {
+      frame.stage = 2;
+      const paramChild = frame.node.paramChild;
+      if (paramChild) {
+        const paramName = paramChild.paramName;
+        if (paramName === void 0) return null;
+        const value = originalPath !== void 0 ? decodeParam(segmentAt(originalPath, frame.pos), decode) : decodeParam(frame.seg, decode);
+        bindNames.push(paramName);
+        bindValues.push(value);
+        frame.bound = true;
+        depth++;
+        const next = frames[depth];
+        if (next === void 0) {
+          bindNames.pop();
+          bindValues.pop();
+          frame.bound = false;
+          depth--;
+          continue;
+        }
+        next.node = paramChild;
+        next.pos = frame.next;
+        next.stage = 0;
+        next.seg = "";
+        next.next = 0;
+        next.bound = false;
+      }
+      continue;
+    }
+    if (frame.bound) {
+      bindNames.pop();
+      bindValues.pop();
+      frame.bound = false;
+    }
+    const wildcardChild = frame.node.wildcardChild;
+    if (wildcardChild) {
+      const src = originalPath ?? path;
+      bindNames.push("*");
+      bindValues.push(decodeParam(src.slice(frame.pos), decode));
+      const handler = wildcardChild.handlers.get(method);
+      if (handler) return handler;
+      bindNames.pop();
+      bindValues.pop();
+    }
+    depth--;
+  }
+  return null;
+}
+__name(matchNodeIndexedPooled, "matchNodeIndexedPooled");
 
 // src/matching.ts
 function decodeParam(value, decode) {
@@ -312,7 +435,10 @@ function normalizePathForMatch(path, caseSensitive, strict) {
   return collapseAndStrip(folded, strict);
 }
 __name(normalizePathForMatch, "normalizePathForMatch");
-function matchNodeIndexed(root, path, startPos, bindNames, bindValues, method, decode, originalPath) {
+function matchNodeIndexed(root, path, startPos, bindNames, bindValues, method, decode, originalPath, pool) {
+  if (pool) {
+    return matchNodeIndexedPooled(root, path, startPos, bindNames, bindValues, method, decode, pool, originalPath);
+  }
   const stack = [
     {
       node: root,
@@ -404,13 +530,22 @@ function matchNodeIndexed(root, path, startPos, bindNames, bindValues, method, d
 __name(matchNodeIndexed, "matchNodeIndexed");
 
 // src/match-route.ts
-function matchRoute(method, rawPath, root, staticRoutes, hasParamRoutes, caseSensitive, strict, decode, routerMiddleware) {
+function matchRoute(method, rawPath, root, staticRoutes, hasParamRoutes, caseSensitive, strict, decode, routerMiddleware, preNormalized = false, walkPool) {
   let path = rawPath;
-  const queryIdx = path.indexOf("?");
-  if (queryIdx !== -1) path = path.slice(0, queryIdx);
-  const caseStable = caseSensitive || isProvablyLowerAscii(path);
-  const folded = caseStable ? path : path.toLowerCase();
-  const normalized = collapseAndStrip(folded, strict);
+  if (!preNormalized) {
+    const queryIdx = path.indexOf("?");
+    if (queryIdx !== -1) path = path.slice(0, queryIdx);
+  }
+  let normalized;
+  let caseStable;
+  if (preNormalized) {
+    normalized = path;
+    caseStable = true;
+  } else {
+    caseStable = caseSensitive || isProvablyLowerAscii(path);
+    const folded = caseStable ? path : path.toLowerCase();
+    normalized = collapseAndStrip(folded, strict);
+  }
   const methodMap = staticRoutes.get(method);
   if (methodMap) {
     const staticKey = normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
@@ -426,16 +561,20 @@ function matchRoute(method, rawPath, root, staticRoutes, hasParamRoutes, caseSen
   }
   if (!hasParamRoutes) return null;
   const originalPath = caseStable ? void 0 : collapseAndStrip(path, strict);
-  const bindNames = [];
-  const bindValues = [];
-  const entry = matchNodeIndexed(root, normalized, 1, bindNames, bindValues, method, decode, originalPath);
+  const bindNames = walkPool ? walkPool.bindNames : [];
+  const bindValues = walkPool ? walkPool.bindValues : [];
+  if (walkPool) {
+    bindNames.length = 0;
+    bindValues.length = 0;
+  }
+  const entry = matchNodeIndexed(root, normalized, 1, bindNames, bindValues, method, decode, originalPath, walkPool);
   if (!entry) return null;
   const count = bindNames.length;
   let params;
   if (count === 0) {
     params = EMPTY_PARAMS;
   } else {
-    params = /* @__PURE__ */ Object.create(null);
+    params = Object.create(NULL_PROTO);
     for (let i = 0; i < count; i++) {
       const name = bindNames[i];
       const value = bindValues[i];
@@ -450,14 +589,15 @@ function matchRoute(method, rawPath, root, staticRoutes, hasParamRoutes, caseSen
   };
 }
 __name(matchRoute, "matchRoute");
-function resolveMatch(state, hasParamRoutes, method, path) {
-  return matchRoute(method, path, state.root, state.staticRoutes, hasParamRoutes, state.caseSensitive, state.strict, state.decode, state.routerMiddleware);
+function resolveMatch(state, hasParamRoutes, method, path, preNormalized = false) {
+  return matchRoute(method, path, state.root, state.staticRoutes, hasParamRoutes, state.caseSensitive, state.strict, state.decode, state.routerMiddleware, preNormalized, state.walkPool);
 }
 __name(resolveMatch, "resolveMatch");
 
 // src/composition.ts
 function copyRoutes(node, prefix, segments, subRouterMiddleware, addRoute2) {
   for (const [method, entry] of node.handlers) {
+    if (entry.autoHead) continue;
     const path = prefix + "/" + segments.join("/");
     const combined = subRouterMiddleware.length > 0 ? [
       ...subRouterMiddleware,
@@ -575,8 +715,20 @@ function normalizeRegistrationPath(path, prefix, strict) {
   return normalized.startsWith("/") ? normalized : "/" + normalized;
 }
 __name(normalizeRegistrationPath, "normalizeRegistrationPath");
+function setStaticEntry(staticRoutes, method, key, entry) {
+  let methodMap = staticRoutes.get(method);
+  if (!methodMap) {
+    methodMap = /* @__PURE__ */ new Map();
+    staticRoutes.set(method, methodMap);
+  }
+  methodMap.set(key, entry);
+}
+__name(setStaticEntry, "setStaticEntry");
 function addRoute(method, normalized, entries, middleware, state, recordIntrospection = true) {
   const segments = parseSegments(normalized, state.caseSensitive);
+  if (segments.length > state.maxDepth) {
+    state.maxDepth = segments.length;
+  }
   let node = state.root;
   for (const seg of segments) {
     if (seg.type === NodeType.PARAM) {
@@ -623,21 +775,30 @@ function addRoute(method, normalized, entries, middleware, state, recordIntrospe
   const handlerEntry = {
     handler: finalHandler,
     middleware: combinedMiddleware,
-    executor
+    executor,
+    autoHead: false
   };
-  if (node.handlers.has(method)) {
+  const existing = node.handlers.get(method);
+  if (existing && !(method === "HEAD" && existing.autoHead)) {
     throw new Error(`Route conflict: ${method} ${normalized} is already registered. Remove the duplicate or use a different path.`);
   }
   node.handlers.set(method, handlerEntry);
   const hasParams = segments.some((s) => s.type === NodeType.PARAM || s.type === NodeType.WILDCARD);
-  if (!hasParams) {
-    const normalizedKey = state.caseSensitive ? normalized : normalized.toLowerCase();
-    let methodMap = state.staticRoutes.get(method);
-    if (!methodMap) {
-      methodMap = /* @__PURE__ */ new Map();
-      state.staticRoutes.set(method, methodMap);
+  const staticKey = hasParams ? void 0 : state.caseSensitive ? normalized : normalized.toLowerCase();
+  if (staticKey !== void 0) {
+    setStaticEntry(state.staticRoutes, method, staticKey, handlerEntry);
+  }
+  if (method === "GET" && !node.handlers.has("HEAD")) {
+    const derived = {
+      handler: finalHandler,
+      middleware: combinedMiddleware,
+      executor,
+      autoHead: true
+    };
+    node.handlers.set("HEAD", derived);
+    if (staticKey !== void 0) {
+      setStaticEntry(state.staticRoutes, "HEAD", staticKey, derived);
     }
-    methodMap.set(normalizedKey, handlerEntry);
   }
   if (recordIntrospection) {
     state.routeDefinitions.push({
@@ -747,11 +908,67 @@ function findAllowedMethods(path, root, caseSensitive, strict) {
 }
 __name(findAllowedMethods, "findAllowedMethods");
 
+// src/canonicalize.ts
+var DOT = 46;
+var SLASH = 47;
+function hasDotSegment(path) {
+  const len = path.length;
+  let segStart = 0;
+  for (let i = 0; i <= len; i++) {
+    const atBoundary = i === len || path.charCodeAt(i) === SLASH;
+    if (!atBoundary) continue;
+    const segLen = i - segStart;
+    if (segLen === 1 && path.charCodeAt(segStart) === DOT) return true;
+    if (segLen === 2 && path.charCodeAt(segStart) === DOT && path.charCodeAt(segStart + 1) === DOT) {
+      return true;
+    }
+    segStart = i + 1;
+  }
+  return false;
+}
+__name(hasDotSegment, "hasDotSegment");
+var memoTarget = void 0;
+var memoCaseSensitive = false;
+var memoStrict = false;
+var memoResult = {
+  rejected: false,
+  path: "/"
+};
+function canonicalizePath(rawTarget, caseSensitive, strict) {
+  if (rawTarget === memoTarget && caseSensitive === memoCaseSensitive && strict === memoStrict) {
+    return memoResult;
+  }
+  const queryIdx = rawTarget.indexOf("?");
+  const path = queryIdx === -1 ? rawTarget : rawTarget.slice(0, queryIdx);
+  const result = hasDotSegment(path) ? {
+    rejected: true,
+    path
+  } : {
+    rejected: false,
+    path: collapseAndStrip(caseSensitive || isProvablyLowerAscii(path) ? path : path.toLowerCase(), strict)
+  };
+  memoTarget = rawTarget;
+  memoCaseSensitive = caseSensitive;
+  memoStrict = strict;
+  memoResult = result;
+  return result;
+}
+__name(canonicalizePath, "canonicalizePath");
+
 // src/dispatch.ts
 var RESOLVED = Promise.resolve();
-function createRoutesMiddleware(match) {
+function createRoutesMiddleware(match, caseSensitive, strict) {
   return (ctx, next) => {
-    const routeMatch = match(ctx.method, ctx.path);
+    const originalPath = ctx.path;
+    const canonical = canonicalizePath(originalPath, caseSensitive, strict);
+    if (canonical.rejected) {
+      ctx.status = 400;
+      ctx.originalPath = originalPath;
+      return RESOLVED;
+    }
+    ctx.path = canonical.path;
+    ctx.originalPath = originalPath;
+    const routeMatch = match(ctx.method, canonical.path);
     if (!routeMatch) {
       ctx.status = 404;
       return next ? next() : RESOLVED;
@@ -803,12 +1020,14 @@ function createRouterState(root, opts, staticRoutes, routeDefinitions, routerMid
     caseSensitive: opts.caseSensitive,
     strict: opts.strict,
     decode: opts.decode,
-    routerMiddleware
+    routerMiddleware,
+    maxDepth: 0
   };
 }
 __name(createRouterState, "createRouterState");
 
 // src/router.ts
+var SLASH_CHAR_CODE = 47;
 var Router = class _Router {
   static {
     __name(this, "Router");
@@ -827,6 +1046,13 @@ var Router = class _Router {
   hasParamRoutes = false;
   /** Whether router-level middleware has already been sealed into executors (audit RT-7) */
   _sealed = false;
+  /**
+  * Single-entry memo for {@link matchesMountPrefix}'s canonicalization of the
+  * mount prefix, which is fixed at registration time. Declared as two fields
+  * rather than an object so a miss stores without allocating.
+  */
+  _prefixMemoRaw = void 0;
+  _prefixMemoCanonical = "";
   /** Memoized state the extracted registration/matching functions read (see {@link createRouterState}). */
   state;
   constructor(options = {}) {
@@ -844,9 +1070,13 @@ var Router = class _Router {
       throw new TypeError(`Route path must be a string, received ${rawPath === null ? "null" : typeof rawPath}.`);
     }
     const normalized = normalizeRegistrationPath(path, this.opts.prefix, this.opts.strict);
+    const depthBefore = this.state.maxDepth;
     if (addRoute(method, normalized, entries, middleware, this.state, recordIntrospection)) {
       this.hasParamRoutes = true;
     }
+    if (this.state.maxDepth > depthBefore) {
+      this.state.walkPool = createWalkPool(this.state.maxDepth);
+    }
   }
   get(path, ...entries) {
     this.addRoute("GET", path, entries);
@@ -939,6 +1169,39 @@ var Router = class _Router {
     return resolveMatch(this.state, this.hasParamRoutes, method, path);
   }
   /**
+  * Test whether `path` falls under `prefix` using this router's OWN
+  * canonicalization (case folding per `caseSensitive`, structural
+  * normalization) — the mount-boundary counterpart to {@link match}, so a
+  * router mounted via `Application.route()` is tested with the identical
+  * rule it dispatches with (RFC-029, task 3.8). Implements the optional
+  * `Routable.matchesMountPrefix` contract from `@nextrush/core`.
+  *
+  * @param path - The full request path being tested for this mount.
+  * @param prefix - The normalized mount prefix (leading `/`, no trailing `/`).
+  * @returns The path's remainder past the prefix (e.g. `/users` for a
+  *   `/ADMIN/Users` request mounted at `/admin`), or `undefined` when `path`
+  *   is not under `prefix` per this router's canonicalization.
+  */
+  matchesMountPrefix(path, prefix) {
+    const canonical = canonicalizePath(path, this.opts.caseSensitive, this.opts.strict);
+    if (canonical.rejected) return void 0;
+    let canonicalPrefix;
+    if (this._prefixMemoRaw === prefix) {
+      canonicalPrefix = this._prefixMemoCanonical;
+    } else {
+      canonicalPrefix = canonicalizePath(prefix, this.opts.caseSensitive, this.opts.strict).path;
+      this._prefixMemoRaw = prefix;
+      this._prefixMemoCanonical = canonicalPrefix;
+    }
+    const prefixLen = canonicalPrefix.length;
+    if (!canonical.path.startsWith(canonicalPrefix)) return void 0;
+    const hasCharAfterPrefix = prefixLen < canonical.path.length;
+    if (hasCharAfterPrefix && canonical.path.charCodeAt(prefixLen) !== SLASH_CHAR_CODE) {
+      return void 0;
+    }
+    return canonical.path.slice(prefixLen) || "/";
+  }
+  /**
   * Return the router's dispatch middleware — mount this on the application.
   * @see {@link https://github.com/0xTanzim/nextRush/blob/main/packages/router/README.md#routerroutes | README: router.routes()}
   */
@@ -947,7 +1210,7 @@ var Router = class _Router {
       this._sealed = true;
       sealRouterMiddleware(this.root, this.staticRoutes, this.routerMiddleware);
     }
-    return createRoutesMiddleware((method, path) => this.match(method, path));
+    return createRoutesMiddleware((method, path) => resolveMatch(this.state, this.hasParamRoutes, method, path, true), this.opts.caseSensitive, this.opts.strict);
   }
   /**
   * Generate allowed-methods middleware. Responds to OPTIONS with an `Allow`
@@ -975,6 +1238,8 @@ var Router = class _Router {
     this.routerMiddleware.length = 0;
     this.hasParamRoutes = false;
     this.routeDefinitions.length = 0;
+    this.state.maxDepth = 0;
+    this.state.walkPool = void 0;
     this._sealed = false;
   }
   /** Register a route on behalf of a {@link RouteGroup} (group context). @internal */
@@ -996,9 +1261,11 @@ __name(createRouter, "createRouter");
 export {
   NodeType,
   Router,
+  canonicalizePath,
   createNode,
   createRouter,
   endpoint,
+  hasDotSegment,
   parseSegments
 };
 //# sourceMappingURL=index.js.map