perf(parse): remove complex regex pattern

Author: TomokiMiyauci

_abnf.ts

@@ -10,25 +10,7 @@ import { optimize } from "https://esm.sh/regexp-tree";
 
 const tchar = /[!#$%&'*+.^_`|~\dA-Za-z-]/;
 const token = atomic(suffix("+", tchar));
-const authScheme = namedCapture("authScheme", token);
 const SP = / /;
-const ALPHA = /[A-Za-z]/;
-const DIGIT = /\d/;
-const token68 = sequence(
-  atomic(suffix("+", either(ALPHA, DIGIT, /[-._~+/]/))),
-  atomic(suffix("*", "=")),
-);
-
-const challenge = sequence(
-  authScheme,
-  maybe(
-    atomic(suffix("+", SP)),
-    either(
-      namedCapture("token68", token68),
-      namedCapture("authParam", atomic(/.*/)),
-    ),
-  ),
-);
 
 const OWS = /[ \t]*/;
 const BWS = OWS;
@@ -64,7 +46,6 @@ const authParam = sequence(
 );
 
 if (import.meta.main) {
-  console.log("challenge:", optimize(challenge).toRegExp());
   console.log("element: ", element);
   console.log("authParam: ", optimize(authParam).toRegExp());
 }

_tools/meta.ts

@@ -74,5 +74,9 @@ export const makeOptions = (version: string): BuildOptions => ({
       version: "1.2.0",
       subPath: "list.js",
     },
+    "https://esm.sh/[email protected]?pin=v118": {
+      name: "escape-string-regexp",
+      version: "5.0.0",
+    },
   },
 });

deno.lock

@@ -9,3 +9,4 @@ export { mapValues } from "https://deno.land/[email protected]/collections/map_values.
 export { isQuotedString } from "https://deno.land/x/[email protected]/quoted_string.ts";
 export { isToken } from "https://deno.land/x/[email protected]/token.ts";
 export { parseListFields } from "https://deno.land/x/[email protected]/list.ts";
+export { default as escapeStringRegExp } from "https://esm.sh/[email protected]?pin=v118";

deps.ts

@@ -1,15 +1,17 @@
 // Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
 // This module is browser compatible.
 
-import { duplicate } from "./utils.ts";
-import { head, isString, parseListFields, toLowerCase } from "./deps.ts";
+import { divideWhile, duplicate, isToken68, trimStartBy } from "./utils.ts";
+import {
+  head,
+  isString,
+  isToken,
+  parseListFields,
+  toLowerCase,
+} from "./deps.ts";
 import { Msg } from "./constants.ts";
 import type { Authorization, AuthParams } from "./types.ts";
 
-/** Generate from _abnf.ts. */
-const reAuthorization =
-  /^(?<authScheme>(?=([\w!#$%&'*+.^`|~-]+))\2)(?:(?=( +))\3(?:(?<token68>(?=((?:[A-Za-z]|\d|[+./_~-])+))\5(?=(=*))\6)|(?<authParam>(?=(.*))\8)))?$/;
-
 /** Parse string into {@link Authorization}.
  *
  * @example
@@ -39,24 +41,28 @@ const reAuthorization =
  * @throws {Error} If the auth param key is duplicated.
  */
 export function parseAuthorization(input: string): Authorization {
-  const result = reAuthorization.exec(input);
+  const result = divideWhile(input, isToken);
 
-  if (!result || !result.groups) throw SyntaxError(Msg.InvalidSyntax);
+  if (!result) throw new SyntaxError(Msg.InvalidSyntax);
 
-  const groups = result.groups as ParsedGroups;
-  const { authScheme } = groups;
-  const params = isString(groups.authParam)
-    ? parseAuthParams(groups.authParam)
-    : groups.token68;
+  const [authScheme, rest] = result;
 
-  return { authScheme, params: params ?? null };
-}
+  // challenge = auth-scheme
+  if (!rest) return { authScheme, params: null };
+  if (!rest.startsWith(" ")) throw new SyntaxError(Msg.InvalidSyntax);
+
+  const maybeToken68OrAuthParam = trimStartBy(rest, " ");
 
-type ParsedGroups = {
-  readonly authScheme: string;
-  readonly token68: string | undefined;
-  readonly authParam: string | undefined;
-};
+  // challenge = auth-scheme [ 1*SP ( token68 ) ]
+  if (isToken68(maybeToken68OrAuthParam)) {
+    return { authScheme, params: maybeToken68OrAuthParam };
+  }
+
+  // challenge = auth-scheme [ 1*SP ( #auth-param ) ]
+  const params = parseAuthParams(maybeToken68OrAuthParam);
+
+  return { authScheme, params };
+}
 
 /** Generate from _abnf.ts. */
 const reAuthParam =
@@ -79,7 +85,7 @@ export function parseAuthParams(input: string): AuthParams {
   const entries = list.map((el) => {
     const result = reAuthParam.exec(el);
 
-    if (!result || !result.groups) throw SyntaxError(Msg.InvalidSyntax);
+    if (!result || !result.groups) throw new SyntaxError(Msg.InvalidSyntax);
 
     const groups = result.groups as AuthParamGroups;
     const value = isString(groups.token)

parse.ts

@@ -1,7 +1,7 @@
 // Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
 // This module is browser compatible.
 
-import { isToken } from "./deps.ts";
+import { escapeStringRegExp, isToken } from "./deps.ts";
 
 export function duplicate<T>(list: readonly T[]): T[] {
   const duplicates = new Set<T>();
@@ -45,3 +45,28 @@ export function assertToken(
 ): asserts input {
   if (!isToken(input)) throw new constructor(msg);
 }
+
+/** Divide two string. The first string is matched, second string is rest. */
+export function divideWhile(
+  input: string,
+  match: (input: string) => boolean,
+): [matched: string, rest: string] | null {
+  let matched = "";
+
+  for (const str of input) {
+    if (!match(str)) break;
+
+    matched += str;
+  }
+
+  if (!matched) return null;
+
+  const rest = input.slice(matched.length);
+
+  return [matched, rest];
+}
+
+/** Trim start by something. */
+export function trimStartBy(input: string, separator: string): string {
+  return input.replace(new RegExp(`^${escapeStringRegExp(separator)}+`), "");
+}

utils.ts

@@ -1,6 +1,13 @@
-import { assertToken, assertToken68, isToken68 } from "./utils.ts";
+import {
+  assertToken,
+  assertToken68,
+  divideWhile,
+  isToken68,
+  trimStartBy,
+} from "./utils.ts";
 import {
   assert,
+  assertEquals,
   assertFalse,
   assertThrows,
   describe,
@@ -68,3 +75,45 @@ describe("assertToken", () => {
     assertThrows(() => assertToken("a=="));
   });
 });
+
+describe("divideWhile", () => {
+  it("should return null if the input does not match", () => {
+    assertEquals(divideWhile("", () => false), null);
+    assertEquals(divideWhile("a", () => false), null);
+    assertEquals(divideWhile("abc", (str) => str === "b"), null);
+  });
+
+  it("should return null if the input does not match", () => {
+    assertEquals(divideWhile("abc", (str) => str === "a"), ["a", "bc"]);
+    assertEquals(divideWhile("abcCBA", (str) => /[a-z]/.test(str)), [
+      "abc",
+      "CBA",
+    ]);
+    assertEquals(
+      divideWhile("あabc亜", (str) => /[a-z]/.test(str) || str === "あ"),
+      [
+        "あabc",
+        "亜",
+      ],
+    );
+    assertEquals(divideWhile("abcCBA", (str) => /.*/.test(str)), [
+      "abcCBA",
+      "",
+    ]);
+  });
+});
+
+describe("trimStartBy", () => {
+  it("should return trimmed string", () => {
+    const table: [string, string, string][] = [
+      ["abc", "a", "bc"],
+      ["abcdefg", "abc", "defg"],
+      ["abcdefg", "aaa", "abcdefg"],
+      ["\\\\abc", "\\", "abc"],
+    ];
+
+    table.forEach(([input, separator, expected]) => {
+      assertEquals(trimStartBy(input, separator), expected);
+    });
+  });
+});