@occultist/occultist 0.0.10 → 0.0.12

package/dist/actions/actionSets.d.ts

@@ -9,7 +9,7 @@ export type ActionAcceptMatch = {
     type: 'match';
     action: ImplementedAction;
     contentType?: string;
-    language?: string;
+    languageTag?: string;
     encoding?: string;
 };
 export type ActionMatchResult = UnsupportedContentTypeMatch | ActionAcceptMatch;
@@ -18,6 +18,11 @@ export type ActionMatchResult = UnsupportedContentTypeMatch | ActionAcceptMatch;
  */
 export declare class ActionSet {
     #private;
-    constructor(rootIRI: string, method: string, path: string, meta: ActionCore[]);
+    constructor(rootIRI: string, method: string, path: string, meta: ActionCore[], reverseExtensions: Map<string, string>);
+    /**
+     * @param method HTTP method to match against.
+     * @param path The pathname of the request.
+     * @param accept The accept cache of th erequest.
+     */
     matches(method: string, path: string, accept: Accept): null | ActionMatchResult;
 }

package/dist/actions/actionSets.js

@@ -8,42 +8,100 @@ export class ActionSet {
     #method;
     #urlPattern;
     #contentTypeActionMap;
+    #extensionMap = new Map();
     #ctc;
-    constructor(rootIRI, method, path, meta) {
+    #autoLanguageTags;
+    constructor(rootIRI, method, path, meta, reverseExtensions) {
         this.#rootIRI = rootIRI;
         this.#method = method;
+        [
+            this.#contentTypeActionMap,
+            this.#extensionMap,
+            this.#ctc,
+            this.#autoLanguageTags,
+        ] = this.#process(meta, reverseExtensions);
+        if (this.#extensionMap.size > 0) {
+            path += ':auto1(\\.[\\w\\-]+)?';
+            // language tags are only enabled if file extensions are
+            if (this.#autoLanguageTags) {
+                path += ':auto2(\\.[a-zA-Z0-9\\-]+)?';
+            }
+        }
         this.#urlPattern = makeURLPattern(path, rootIRI);
-        [this.#contentTypeActionMap, this.#ctc] = this.#process(meta);
     }
+    /**
+     * @param method HTTP method to match against.
+     * @param path The pathname of the request.
+     * @param accept The accept cache of th erequest.
+     */
     matches(method, path, accept) {
         if (method !== this.#method) {
             return null;
         }
-        else if (!this.#urlPattern.test(path, this.#rootIRI)) {
+        const res = this.#urlPattern.exec(path, this.#rootIRI);
+        if (res == null) {
             return null;
         }
-        const contentType = accept.negotiate(this.#ctc);
+        let contentType;
+        let languageTag;
+        if (res.pathname.groups.auto1 != null && res.pathname.groups.auto2 != null) {
+            languageTag = res.pathname.groups.auto1.replace('.', '');
+            const fileExtension = res.pathname.groups.auto2.replace('.', '');
+            contentType = this.#extensionMap.get(fileExtension);
+            if (contentType == null)
+                return null;
+        }
+        else if (res.pathname.groups.auto1 != null || res.pathname.groups.auto2 != null) {
+            const autoParam = res.pathname.groups.auto1 ?? res.pathname.groups.auto2;
+            const fileExtension = autoParam.replace('.', '');
+            contentType = this.#extensionMap.get(fileExtension);
+            if (contentType == null)
+                return null;
+        }
+        if (contentType == null) {
+            contentType = accept.negotiate(this.#ctc);
+        }
+        if (contentType == null)
+            return null;
         const action = this.#contentTypeActionMap.get(contentType);
-        if (contentType != null && action != null) {
+        if (action != null) {
             return {
                 type: 'match',
                 action,
                 contentType,
+                languageTag,
             };
         }
         return null;
     }
-    #process(meta) {
+    #process(meta, reverseExtensions) {
+        let autoLanguageTags = false;
         const contentTypes = [];
         const contentTypeActionMap = new Map();
-        for (let i = 0; i < meta.length; i++) {
+        const extensionMap = new Map();
+        let l1 = meta.length;
+        for (let i = 0; i < l1; i++) {
             const action = meta[i].action;
-            for (let j = 0; j < action.contentTypes.length; j++) {
+            let l2 = action.contentTypes.length;
+            for (let j = 0; j < l2; j++) {
                 const contentType = action.contentTypes[j];
                 contentTypes.push(contentType);
                 contentTypeActionMap.set(contentType, action);
+                if (!autoLanguageTags && meta[i].autoLanguageTags) {
+                    autoLanguageTags = true;
+                }
+                if (meta[i].autoFileExtensions &&
+                    reverseExtensions.has(contentType) &&
+                    !extensionMap.has(contentType)) {
+                    extensionMap.set(reverseExtensions.get(contentType), contentType);
+                }
             }
         }
-        return [contentTypeActionMap, new ContentTypeCache(contentTypes)];
+        return [
+            contentTypeActionMap,
+            extensionMap,
+            new ContentTypeCache(contentTypes),
+            autoLanguageTags,
+        ];
     }
 }

package/dist/actions/actions.d.ts

@@ -3,6 +3,7 @@ import type { JSONLDContext, JSONObject, TypeDef } from "../jsonld.ts";
 import type { Registry } from '../registry.ts';
 import type { Scope } from "../scopes.ts";
 import { MiddlewareRefs, type ActionCore } from "./core.ts";
+import { Route } from './route.ts';
 import type { ActionSpec, ContextState } from "./spec.ts";
 import type { AuthMiddleware, AuthState, HandlerFn, HandlerMeta, HandlerObj, HandlerValue, HintArgs, ImplementedAction } from './types.ts';
 import { type ResponseTypes } from './writer.ts';
@@ -15,13 +16,13 @@ export type DefineArgs<Term extends string = string, Spec extends ActionSpec = A
  * after an action is defined.
  */
 export declare class HandlerDefinition<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Spec extends ActionSpec = ActionSpec> {
-    name: string;
+    name?: string;
     contentType: string;
     handler: HandlerFn | HandlerValue;
     meta: HandlerMeta;
     action: ImplementedAction<State, Auth, Spec>;
     cache: ReadonlyArray<CacheInstanceArgs>;
-    constructor(name: string, contentType: string, handler: HandlerFn | HandlerValue, meta: HandlerMeta, action: ImplementedAction<State, Auth, Spec>, actionMeta: ActionCore);
+    constructor(name: string | undefined, contentType: string, handler: HandlerFn | HandlerValue, meta: HandlerMeta, action: ImplementedAction<State, Auth, Spec>, actionMeta: ActionCore);
     get [Symbol.toStringTag](): string;
 }
 export interface Handleable<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Spec extends ActionSpec = ActionSpec> {
@@ -45,9 +46,9 @@ export declare class FinalizedAction<State extends ContextState = ContextState,
     get term(): string | undefined;
     get type(): string | undefined;
     get typeDef(): TypeDef | undefined;
-    get name(): string;
+    get name(): string | undefined;
     get template(): string;
-    get pattern(): URLPattern;
+    get route(): Route;
     get spec(): Spec;
     get scope(): Scope | undefined;
     get registry(): Registry;
@@ -84,9 +85,9 @@ export declare class DefinedAction<State extends ContextState = ContextState, Au
     get term(): string | undefined;
     get type(): string | undefined;
     get typeDef(): TypeDef | undefined;
-    get name(): string;
+    get name(): string | undefined;
     get template(): string;
-    get pattern(): URLPattern;
+    get route(): Route;
     get path(): string;
     get spec(): Spec;
     get scope(): Scope | undefined;
@@ -131,9 +132,9 @@ export declare class Action<State extends ContextState = ContextState, Auth exte
     get term(): string | undefined;
     get type(): string | undefined;
     get typeDef(): TypeDef | undefined;
-    get name(): string;
+    get name(): string | undefined;
     get template(): string;
-    get pattern(): URLPattern;
+    get route(): Route;
     get path(): string;
     get spec(): ActionSpec;
     get scope(): Scope | undefined;

package/dist/actions/actions.js

@@ -31,7 +31,7 @@ export class HandlerDefinition {
         Object.freeze(this);
     }
     get [Symbol.toStringTag]() {
-        return `name=${this.name} contentType=${this.contentType}`;
+        return `name=${this.name ?? 'anon'} contentType=${this.contentType}`;
     }
 }
 export class FinalizedAction {
@@ -65,7 +65,7 @@ export class FinalizedAction {
         return new FinalizedAction(typeDef, spec, core, arg3);
     }
     static async toJSONLD(action, scope) {
-        if (scope == null || action.typeDef == null) {
+        if (scope == null || action.typeDef == null || action.name == null) {
             return null;
         }
         const apiSpec = await getPropertyValueSpecifications(action.spec);
@@ -103,8 +103,8 @@ export class FinalizedAction {
     get template() {
         return this.#core.uriTemplate;
     }
-    get pattern() {
-        return this.#core.path.pattern;
+    get route() {
+        return this.#core.route;
     }
     get spec() {
         return this.#spec;
@@ -129,7 +129,7 @@ export class FinalizedAction {
         });
     }
     url() {
-        return joinPaths(this.#core.registry.rootIRI, this.#core.path.normalized);
+        return joinPaths(this.#core.registry.rootIRI, this.#core.route.normalized);
     }
     /**
      * Retrives the handler configured for the given content type.
@@ -239,11 +239,11 @@ export class DefinedAction {
     get template() {
         return this.#core.uriTemplate;
     }
-    get pattern() {
-        return this.#core.path.pattern;
+    get route() {
+        return this.#core.route;
     }
     get path() {
-        return this.#core.path.normalized;
+        return this.#core.route.normalized;
     }
     get spec() {
         return this.#spec;
@@ -364,11 +364,11 @@ export class Action {
     get template() {
         return this.#core.uriTemplate;
     }
-    get pattern() {
-        return this.#core.path.pattern;
+    get route() {
+        return this.#core.route;
     }
     get path() {
-        return this.#core.path.normalized;
+        return this.#core.route.normalized;
     }
     get spec() {
         return this.#spec;

package/dist/actions/context.d.ts

@@ -6,6 +6,7 @@ import type { ResponseBody } from "./writer.ts";
 export type CacheContextArgs<Auth extends AuthState = AuthState> = {
     req: Request;
     contentType: string;
+    languageTag: string | undefined;
     public: boolean;
     authKey?: string;
     auth: Auth;
@@ -23,7 +24,8 @@ export declare class CacheContext<Auth extends AuthState = AuthState> {
     req: Request;
     method: string;
     url: string;
-    contentType: string;
+    contentType?: string;
+    languageTag?: string;
     public: boolean;
     authKey: string | null;
     auth: Auth;
@@ -48,6 +50,7 @@ export declare class CacheContext<Auth extends AuthState = AuthState> {
 export type ContextArgs<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Spec extends ActionSpec = ActionSpec> = {
     req: Request;
     contentType: string;
+    languageTag: string | undefined;
     public: boolean;
     authKey?: string;
     auth: Auth;
@@ -67,6 +70,7 @@ export declare class Context<State extends ContextState = ContextState, Auth ext
     method: string;
     url: string;
     contentType: string;
+    languageTag?: string;
     public: boolean;
     authKey?: string;
     auth: Auth;

package/dist/actions/context.js

@@ -16,6 +16,7 @@ export class CacheContext {
     method;
     url;
     contentType;
+    languageTag;
     public;
     authKey;
     auth;
@@ -30,6 +31,7 @@ export class CacheContext {
         this.req = args.req;
         this.url = args.req.url;
         this.contentType = args.contentType;
+        this.languageTag = args.languageTag;
         this.public = args.public;
         this.authKey = args.authKey;
         this.auth = args.auth;
@@ -80,6 +82,7 @@ export class Context {
     method;
     url;
     contentType;
+    languageTag;
     public = false;
     authKey;
     auth;
@@ -96,6 +99,7 @@ export class Context {
         this.req = args.req;
         this.url = args.req.url;
         this.contentType = args.contentType;
+        this.languageTag = args.languageTag;
         this.public = args.public;
         this.authKey = args.authKey;
         this.auth = args.auth;

package/dist/actions/core.d.ts

@@ -5,7 +5,7 @@ import type { Registry } from '../registry.ts';
 import type { Scope } from "../scopes.ts";
 import { HandlerDefinition } from './actions.ts';
 import { CacheContext, Context } from './context.ts';
-import { Path } from "./path.ts";
+import { Route } from "./route.ts";
 import type { ActionSpec, ContextState, FileValue, NextFn, TransformerFn } from './spec.ts';
 import type { AuthMiddleware, AuthState, CacheHitHeader, HintArgs, ImplementedAction } from './types.ts';
 import { type HTTPWriter, type ResponseTypes } from "./writer.ts";
@@ -27,13 +27,14 @@ export declare class MiddlewareRefs<State extends ContextState, Auth extends Aut
     headers: Headers;
     handler?: HandlerDefinition<State, Auth, Spec>;
     contentType: string | null;
+    languageTag: string | null;
     writer: HTTPWriter;
     req: Request;
     recordServerTiming: boolean;
     prevTime: number | null;
     serverTimes: string[];
     cacheHitHeader: CacheHitHeader;
-    constructor(req: Request, writer: HTTPWriter, contentType: string | null, prevTime: number | null);
+    constructor(req: Request, writer: HTTPWriter, contentType: string | null, languageTag: string | null, prevTime: number | null);
     recordServerTime(name: string): void;
 }
 /**
@@ -45,11 +46,11 @@ export declare class ActionCore<State extends ContextState = ContextState, Auth
     rootIRI: string;
     method: string;
     isSafe: boolean;
-    name: string;
+    name?: string;
     uriTemplate: string;
     public: boolean;
     authKey?: string;
-    path: Path;
+    route: Route;
     hints: HintArgs[];
     transformers: Map<string, TransformerFn<JSONValue | FileValue, State, Spec>>;
     scope?: Scope;
@@ -61,8 +62,10 @@ export declare class ActionCore<State extends ContextState = ContextState, Auth
     cacheOccurance: 0 | 1;
     auth?: AuthMiddleware<Auth>;
     cache: CacheInstanceArgs[];
+    autoLanguageTags: boolean;
+    autoFileExtensions: boolean;
     recordServerTiming: boolean;
-    constructor(rootIRI: string, method: string, name: string, uriTemplate: string, registry: Registry, writer: HTTPWriter, scope?: Scope);
+    constructor(rootIRI: string, method: string, name: string | undefined, uriTemplate: string, registry: Registry, writer: HTTPWriter, scope: Scope | undefined, autoLanguageTags: boolean, autoFileExtensions: boolean, recordServerTiming: boolean | undefined);
     /**
      * Called when the API is defined to compute all uncomputed values.
      */

package/dist/actions/core.js

@@ -3,7 +3,7 @@ import { ProblemDetailsError } from "../errors.js";
 import { processAction } from "../processAction.js";
 import { joinPaths } from "../utils/joinPaths.js";
 import { CacheContext, Context } from "./context.js";
-import { Path } from "./path.js";
+import { Route } from "./route.js";
 const safeMethods = new Set([
     'OPTIONS',
     'HEAD',
@@ -29,16 +29,18 @@ export class MiddlewareRefs {
     headers;
     handler;
     contentType;
+    languageTag;
     writer;
     req;
     recordServerTiming;
     prevTime;
     serverTimes = [];
     cacheHitHeader;
-    constructor(req, writer, contentType, prevTime) {
+    constructor(req, writer, contentType, languageTag, prevTime) {
         this.req = req;
         this.writer = writer;
         this.contentType = contentType;
+        this.languageTag = languageTag;
         this.prevTime = prevTime;
         this.headers = new Headers();
     }
@@ -59,12 +61,12 @@ export class MiddlewareRefs {
 export class ActionCore {
     rootIRI;
     method;
-    isSafe = false;
+    isSafe;
     name;
     uriTemplate;
     public = false;
     authKey;
-    path;
+    route;
     hints = [];
     transformers = new Map();
     scope;
@@ -76,8 +78,10 @@ export class ActionCore {
     cacheOccurance = BeforeDefinition;
     auth;
     cache = [];
-    recordServerTiming = false;
-    constructor(rootIRI, method, name, uriTemplate, registry, writer, scope) {
+    autoLanguageTags;
+    autoFileExtensions;
+    recordServerTiming;
+    constructor(rootIRI, method, name, uriTemplate, registry, writer, scope, autoLanguageTags, autoFileExtensions, recordServerTiming) {
         this.rootIRI = rootIRI;
         this.method = method.toUpperCase();
         this.isSafe = safeMethods.has(this.method);
@@ -86,7 +90,10 @@ export class ActionCore {
         this.registry = registry;
         this.writer = writer;
         this.scope = scope;
-        this.path = new Path(uriTemplate, rootIRI);
+        this.route = new Route(uriTemplate, rootIRI, autoLanguageTags, autoFileExtensions);
+        this.autoLanguageTags = autoLanguageTags;
+        this.autoFileExtensions = autoFileExtensions;
+        this.recordServerTiming = recordServerTiming ?? false;
     }
     /**
      * Called when the API is defined to compute all uncomputed values.
@@ -134,7 +141,7 @@ export class ActionCore {
                 found = when(cacheCtx);
             }
             if (found) {
-                return new CacheDescriptor(contentType, this.action, req, this.cache[i]);
+                return new CacheDescriptor(contentType, cacheCtx.languageTag, this.action, req, this.cache[i]);
             }
         }
         return null;
@@ -276,6 +283,7 @@ export class ActionCore {
             refs.handlerCtx = new Context({
                 req: refs.req,
                 contentType: refs.contentType,
+                languageTag: refs.languageTag,
                 public: this.public && refs.authKey == null,
                 auth: refs.auth,
                 authKey: refs.authKey,
@@ -307,6 +315,7 @@ export class ActionCore {
             refs.cacheCtx = new CacheContext({
                 req: refs.req,
                 contentType: refs.contentType,
+                languageTag: refs.languageTag,
                 public: this.public && refs.authKey == null,
                 cacheOperation: refs.cacheOperation,
                 auth: refs.auth,
@@ -340,7 +349,9 @@ export class ActionCore {
         if (this.hints.length !== 0) {
             const downstream = refs.next;
             refs.next = async () => {
-                await Promise.all(this.hints.map((hint) => refs.writer.writeEarlyHints(hint)));
+                for (let i = 0; i < this.hints.length; i++) {
+                    refs.writer.writeEarlyHints(this.hints[i]);
+                }
                 await downstream();
             };
         }

package/dist/actions/route.d.ts

@@ -0,0 +1,39 @@
+export type RouteMatchResult = {
+    path: Record<string, string>;
+    query: Record<string, undefined | string | string[]>;
+};
+/**
+ * Util class for handling paths defined using URI templates.
+ * https://datatracker.ietf.org/doc/html/rfc6570.
+ *
+ * URI Templates are used instead of URLPattern format to conform to
+ * JSON-ld https://schema.org/entryPoint needs. It is possible to add
+ * regex syntax which would end up in the generated URLPattern making
+ * it in conflict with the URITemplate. To be fixed...
+ */
+export declare class Route {
+    #private;
+    constructor(template: string, rootURL: string, autoLanguageTag: boolean, autoFileExtension: boolean);
+    get template(): string;
+    get regexp(): RegExp;
+    get pattern(): URLPattern;
+    /**
+     * A normalized form of the url template where arguments are named
+     * in order of appearance instead of with the provided names. This
+     * allows two paths to be compared based of their ability to match
+     * to the same request.
+     */
+    get normalized(): string;
+    /**
+     * Matches a URL against this route and returns the
+     * path and query values.
+     *
+     * @param url The URL to match.
+     */
+    match(url: string | URL): undefined | RouteMatchResult;
+    /**
+     * Returns the location of the given key if it is present in
+     * the path.
+     */
+    locationOf(key: string): 'path' | 'query' | 'fragment' | null;
+}

package/dist/actions/route.js

@@ -0,0 +1,166 @@
+import { makeURLPattern } from "../utils/makeURLPattern.js";
+const paramsRe = /((?<s>[^\{\}]+)|({(?<t>[\?\#\.])?(?<v>[^}]+)}))/g;
+const languageTagReStr = '(?:\\.(?<languageTag>[a-zA-Z0-9][a-zA-Z0-9\\-]+))';
+const fileExtensionReStr = '(?:\\.(?<fileExtension>[a-z][a-zA-Z0-9\\-]+))';
+/**
+ * Util class for handling paths defined using URI templates.
+ * https://datatracker.ietf.org/doc/html/rfc6570.
+ *
+ * URI Templates are used instead of URLPattern format to conform to
+ * JSON-ld https://schema.org/entryPoint needs. It is possible to add
+ * regex syntax which would end up in the generated URLPattern making
+ * it in conflict with the URITemplate. To be fixed...
+ */
+export class Route {
+    #rootURL;
+    #template;
+    #regexp;
+    #pattern;
+    #normalized;
+    #pathKeys = new Set();
+    #queryKeys = new Set();
+    #fragmentKeys = new Set();
+    #autoLanguageTag;
+    #autoFileExtension;
+    constructor(template, rootURL, autoLanguageTag, autoFileExtension) {
+        this.#template = template;
+        this.#rootURL = rootURL;
+        this.#autoLanguageTag = autoLanguageTag;
+        this.#autoFileExtension = autoFileExtension;
+        [this.#pattern, this.#normalized] = this.#makePatterns();
+    }
+    get template() {
+        return this.#template;
+    }
+    get regexp() {
+        return this.#regexp;
+    }
+    get pattern() {
+        return this.#pattern;
+    }
+    /**
+     * A normalized form of the url template where arguments are named
+     * in order of appearance instead of with the provided names. This
+     * allows two paths to be compared based of their ability to match
+     * to the same request.
+     */
+    get normalized() {
+        return this.#normalized;
+    }
+    /**
+     * Matches a URL against this route and returns the
+     * path and query values.
+     *
+     * @param url The URL to match.
+     */
+    match(url) {
+        if (!url.toString().startsWith(this.#rootURL)) {
+            return;
+        }
+        const url2 = new URL(url);
+        const match = this.#regexp.exec(url2.pathname);
+        if (match?.groups == null) {
+            return;
+        }
+        const path = Object.create(null);
+        const query = Object.create(null);
+        for (const [key, value] of Object.entries(match.groups)) {
+            path[key] = value;
+        }
+        for (const key of url2.searchParams.keys()) {
+            const value = url2.searchParams.getAll(key);
+            if (value.length > 1) {
+                query[key] = value;
+            }
+            else {
+                query[key] = value[0];
+            }
+        }
+        return { path, query };
+    }
+    /**
+     * Returns the location of the given key if it is present in
+     * the path.
+     */
+    locationOf(key) {
+        if (this.#pathKeys.has(key)) {
+            return 'path';
+        }
+        else if (this.#queryKeys.has(key)) {
+            return 'query';
+        }
+        else if (this.#fragmentKeys.has(key)) {
+            return 'fragment';
+        }
+        return null;
+    }
+    #makePatterns() {
+        let pattern = '';
+        let normalized = '';
+        // assign values to key location sets for quick querying
+        let match;
+        let foundQueryOrFragment = false;
+        let index = 0;
+        let template = '';
+        let regexpStr = '^';
+        while ((match = paramsRe.exec(this.#template))) {
+            const segment = match.groups?.s;
+            const type = match.groups?.t;
+            const value = match.groups?.v;
+            if (type != null && type !== '.' && !foundQueryOrFragment) {
+                foundQueryOrFragment = true;
+                if (this.#autoLanguageTag && this.#autoFileExtension) {
+                    regexpStr += `(${languageTagReStr}?${fileExtensionReStr})?`;
+                    template += '{.languageTag,fileExtension}';
+                }
+                else if (this.#autoFileExtension) {
+                    regexpStr += fileExtensionReStr + '?';
+                    template += '{.fileExtension}';
+                }
+            }
+            template += match[0];
+            if (!foundQueryOrFragment && segment != null && type == null) {
+                regexpStr += segment;
+                normalized += segment;
+                pattern += segment;
+            }
+            if (value == null) {
+                continue;
+            }
+            if (type === '.' && !foundQueryOrFragment && value != null) {
+                index++;
+                regexpStr += `(\\.(?<${value}>[^\\/\\.]+))`;
+                pattern += `.:${value}`;
+                normalized += `.:value${index}`;
+                this.#pathKeys.add(value);
+            }
+            else if (!foundQueryOrFragment && value != null) {
+                index++;
+                regexpStr += `(?<${value}>[^\\/\\.]+)`;
+                pattern += `:${value}`;
+                normalized += `:value${index}`;
+                this.#pathKeys.add(value);
+            }
+        }
+        if (!foundQueryOrFragment) {
+            if (this.#autoLanguageTag && this.#autoFileExtension) {
+                regexpStr += `(${languageTagReStr}?${fileExtensionReStr})`;
+                template += '{.languageTag,fileExtension}';
+                this.#pathKeys.add('languageTag');
+                this.#pathKeys.add('fileExtension');
+            }
+            else if (this.#autoFileExtension) {
+                regexpStr += fileExtensionReStr;
+                template += '{.fileExtension}';
+                this.#pathKeys.add('fileExtension');
+            }
+        }
+        regexpStr += '$';
+        this.#template = template;
+        this.#regexp = new RegExp(regexpStr);
+        return [
+            makeURLPattern(pattern, this.#rootURL),
+            normalized,
+        ];
+    }
+}