js-routes 2.3.6 → 2.3.7

data/lib/routes.ts

@@ -25,17 +25,17 @@ type RouteHelperExtras = {
 type RequiredParameters<T extends number> = T extends 1
   ? [RequiredRouteParameter]
   : T extends 2
-  ? [RequiredRouteParameter, RequiredRouteParameter]
-  : T extends 3
-  ? [RequiredRouteParameter, RequiredRouteParameter, RequiredRouteParameter]
-  : T extends 4
-  ? [
-      RequiredRouteParameter,
-      RequiredRouteParameter,
-      RequiredRouteParameter,
-      RequiredRouteParameter
-    ]
-  : RequiredRouteParameter[];
+    ? [RequiredRouteParameter, RequiredRouteParameter]
+    : T extends 3
+      ? [RequiredRouteParameter, RequiredRouteParameter, RequiredRouteParameter]
+      : T extends 4
+        ? [
+            RequiredRouteParameter,
+            RequiredRouteParameter,
+            RequiredRouteParameter,
+            RequiredRouteParameter,
+          ]
+        : RequiredRouteParameter[];
 
 type RouteHelperOptions = RouteOptions & Collection<OptionalRouteParameter>;
 
@@ -94,677 +94,662 @@ declare const define:
 
 declare const module: { exports: unknown } | undefined;
 
-// eslint-disable-next-line
-RubyVariables.WRAPPER(
-  // eslint-disable-next-line
-  (): RouterExposedMethods => {
-    const hasProp = (value: unknown, key: string): boolean =>
-      Object.prototype.hasOwnProperty.call(value, key);
-    enum NodeTypes {
-      GROUP = 1,
-      CAT = 2,
-      SYMBOL = 3,
-      OR = 4,
-      STAR = 5,
-      LITERAL = 6,
-      SLASH = 7,
-      DOT = 8,
-    }
-    type RouteNodes = {
-      [NodeTypes.GROUP]: { left: RouteTree; right: never };
-      [NodeTypes.STAR]: { left: RouteTree; right: never };
-      [NodeTypes.LITERAL]: { left: string; right: never };
-      [NodeTypes.SLASH]: { left: "/"; right: never };
-      [NodeTypes.DOT]: { left: "."; right: never };
-      [NodeTypes.CAT]: { left: RouteTree; right: RouteTree };
-      [NodeTypes.SYMBOL]: { left: string; right: never };
-    };
-    type RouteNode<T extends keyof RouteNodes> = [
-      T,
-      RouteNodes[T]["left"],
-      RouteNodes[T]["right"]
-    ];
-    type RouteTree = {
-      [T in keyof RouteNodes]: RouteNode<T>;
-    }[keyof RouteNodes];
-
-    const isBrowser = typeof window !== "undefined";
-    type ModuleDefinition = {
-      define: (routes: RouterExposedMethods) => void;
-      isSupported: () => boolean;
-    };
-
-    const UnescapedSpecials = "-._~!$&'()*+,;=:@"
-      .split("")
-      .map((s) => s.charCodeAt(0));
-    const UnescapedRanges = [
-      ["a", "z"],
-      ["A", "Z"],
-      ["0", "9"],
-    ].map((range) => range.map((s) => s.charCodeAt(0)));
-
-    const ModuleReferences: Record<ModuleType, ModuleDefinition> = {
-      CJS: {
-        define(routes) {
-          if (module) {
-            module.exports = routes;
-          }
-        },
-        isSupported() {
-          return typeof module === "object";
-        },
+RubyVariables.WRAPPER((): RouterExposedMethods => {
+  const hasProp = (value: unknown, key: string): boolean =>
+    Object.prototype.hasOwnProperty.call(value, key);
+  enum NodeTypes {
+    GROUP = 1,
+    CAT = 2,
+    SYMBOL = 3,
+    OR = 4,
+    STAR = 5,
+    LITERAL = 6,
+    SLASH = 7,
+    DOT = 8,
+  }
+  type RouteNodes = {
+    [NodeTypes.GROUP]: { left: RouteTree; right: never };
+    [NodeTypes.STAR]: { left: RouteTree; right: never };
+    [NodeTypes.LITERAL]: { left: string; right: never };
+    [NodeTypes.SLASH]: { left: "/"; right: never };
+    [NodeTypes.DOT]: { left: "."; right: never };
+    [NodeTypes.CAT]: { left: RouteTree; right: RouteTree };
+    [NodeTypes.SYMBOL]: { left: string; right: never };
+  };
+  type RouteNode<T extends keyof RouteNodes> = [
+    T,
+    RouteNodes[T]["left"],
+    RouteNodes[T]["right"],
+  ];
+  type RouteTree = {
+    [T in keyof RouteNodes]: RouteNode<T>;
+  }[keyof RouteNodes];
+
+  const isBrowser = typeof window !== "undefined";
+  type ModuleDefinition = {
+    define: (routes: RouterExposedMethods) => void;
+    isSupported: () => boolean;
+  };
+
+  const UnescapedSpecials = "-._~!$&'()*+,;=:@"
+    .split("")
+    .map((s) => s.charCodeAt(0));
+  const UnescapedRanges = [
+    ["a", "z"],
+    ["A", "Z"],
+    ["0", "9"],
+  ].map((range) => range.map((s) => s.charCodeAt(0)));
+
+  const ModuleReferences: Record<ModuleType, ModuleDefinition> = {
+    CJS: {
+      define(routes) {
+        if (module) {
+          // Some javascript processors (like vite/rolldown)
+          // warn on using module dot exports in an ESM module.
+          // This just obfuscates that assignment a little so
+          // users don't get a warning they can't fix.
+          const _mod = module;
+          _mod.exports = routes;
+        }
       },
-      AMD: {
-        define(routes) {
-          if (define) {
-            define([], function () {
-              return routes;
-            });
-          }
-        },
-        isSupported() {
-          return typeof define === "function" && !!define.amd;
-        },
+      isSupported() {
+        return typeof module === "object";
       },
-      UMD: {
-        define(routes) {
-          if (ModuleReferences.AMD.isSupported()) {
-            ModuleReferences.AMD.define(routes);
-          } else {
-            if (ModuleReferences.CJS.isSupported()) {
-              try {
-                ModuleReferences.CJS.define(routes);
-              } catch (error) {
-                if (error.name !== "TypeError") throw error;
-              }
+    },
+    AMD: {
+      define(routes) {
+        if (define) {
+          define([], function () {
+            return routes;
+          });
+        }
+      },
+      isSupported() {
+        return typeof define === "function" && !!define.amd;
+      },
+    },
+    UMD: {
+      define(routes) {
+        if (ModuleReferences.AMD.isSupported()) {
+          ModuleReferences.AMD.define(routes);
+        } else {
+          if (ModuleReferences.CJS.isSupported()) {
+            try {
+              ModuleReferences.CJS.define(routes);
+            } catch (error) {
+              if ((error as Error).name !== "TypeError") throw error;
             }
           }
-        },
-        isSupported() {
-          return (
-            ModuleReferences.AMD.isSupported() ||
-            ModuleReferences.CJS.isSupported()
-          );
-        },
+        }
+      },
+      isSupported() {
+        return (
+          ModuleReferences.AMD.isSupported() ||
+          ModuleReferences.CJS.isSupported()
+        );
       },
-      ESM: {
-        define() {
-          // Module can only be defined using ruby code generation
-        },
-        isSupported() {
-          // Its impossible to check if "export" keyword is supported
-          return true;
-        },
+    },
+    ESM: {
+      define() {
+        // Module can only be defined using ruby code generation
       },
-      NIL: {
-        define() {
-          // Defined using RubyVariables.WRAPPER
-        },
-        isSupported() {
-          return true;
-        },
+      isSupported() {
+        // Its impossible to check if "export" keyword is supported
+        return true;
       },
-      DTS: {
-        // Acts the same as ESM
-        define(routes) {
-          ModuleReferences.ESM.define(routes);
-        },
-        isSupported() {
-          return ModuleReferences.ESM.isSupported();
-        },
+    },
+    NIL: {
+      define() {
+        // Defined using RubyVariables . WRAPPER
       },
-    };
-
-    class ParametersMissing extends Error {
-      readonly keys: string[];
-      constructor(...keys: string[]) {
-        super(`Route missing required keys: ${keys.join(", ")}`);
-        this.keys = keys;
-        Object.setPrototypeOf(this, Object.getPrototypeOf(this));
-        this.name = ParametersMissing.name;
-      }
+      isSupported() {
+        return true;
+      },
+    },
+    DTS: {
+      // Acts the same as ESM
+      define(routes) {
+        ModuleReferences.ESM.define(routes);
+      },
+      isSupported() {
+        return ModuleReferences.ESM.isSupported();
+      },
+    },
+  };
+
+  class ParametersMissing extends Error {
+    readonly keys: string[];
+    constructor(...keys: string[]) {
+      super(`Route missing required keys: ${keys.join(", ")}`);
+      this.keys = keys;
+      Object.setPrototypeOf(this, Object.getPrototypeOf(this));
+      this.name = ParametersMissing.name;
     }
+  }
 
-    const ReservedOptions = [
-      "anchor",
-      "trailing_slash",
-      "subdomain",
-      "host",
-      "port",
-      "protocol",
-      "script_name",
-    ] as const;
-
-    type ReservedOption = (typeof ReservedOptions)[any];
-
-    class UtilsClass {
-      configuration: Configuration = {
-        prefix: RubyVariables.PREFIX,
-        default_url_options: RubyVariables.DEFAULT_URL_OPTIONS,
-        special_options_key: RubyVariables.SPECIAL_OPTIONS_KEY,
-        serializer:
-          RubyVariables.SERIALIZER || this.default_serializer.bind(this),
-      };
+  const ReservedOptions = [
+    "anchor",
+    "trailing_slash",
+    "subdomain",
+    "host",
+    "port",
+    "protocol",
+    "script_name",
+  ] as const;
+
+  type ReservedOption = (typeof ReservedOptions)[any];
+
+  class UtilsClass {
+    configuration: Configuration = {
+      prefix: RubyVariables.PREFIX,
+      default_url_options: RubyVariables.DEFAULT_URL_OPTIONS,
+      special_options_key: RubyVariables.SPECIAL_OPTIONS_KEY,
+      serializer:
+        RubyVariables.SERIALIZER || this.default_serializer.bind(this),
+    };
 
-      default_serializer(value: unknown, prefix?: string | null): string {
-        if (!prefix && !this.is_object(value)) {
-          throw new Error("Url parameters should be a javascript hash");
+    default_serializer(value: unknown, prefix?: string | null): string {
+      if (!prefix && !this.is_object(value)) {
+        throw new Error("Url parameters should be a javascript hash");
+      }
+      prefix = prefix || "";
+      const result: string[] = [];
+      if (this.is_array(value)) {
+        for (const element of value) {
+          result.push(this.default_serializer(element, prefix + "[]"));
         }
-        prefix = prefix || "";
-        const result: string[] = [];
-        if (this.is_array(value)) {
-          for (const element of value) {
-            result.push(this.default_serializer(element, prefix + "[]"));
+      } else if (this.is_object(value)) {
+        for (let key in value) {
+          if (!hasProp(value, key)) continue;
+          let prop = value[key];
+          if (prefix) {
+            key = prefix + "[" + key + "]";
           }
-        } else if (this.is_object(value)) {
-          for (let key in value) {
-            if (!hasProp(value, key)) continue;
-            let prop = value[key];
-            if (prefix) {
-              key = prefix + "[" + key + "]";
-            }
-            const subvalue = this.default_serializer(prop, key);
-            if (subvalue.length) {
-              result.push(subvalue);
-            }
+          const subvalue = this.default_serializer(prop, key);
+          if (subvalue.length) {
+            result.push(subvalue);
           }
-        } else {
-          result.push(
-            this.is_not_nullable(value) ||
-              RubyVariables.DEPRECATED_NIL_QUERY_PARAMETER_BEHAVIOR
-              ? encodeURIComponent(prefix) +
-                  "=" +
-                  encodeURIComponent("" + (value ?? ""))
-              : encodeURIComponent(prefix)
-          );
         }
-        return result.join("&");
+      } else {
+        const key = encodeURIComponent(prefix);
+        result.push(
+          this.is_not_nullable(value) ||
+            RubyVariables.DEPRECATED_NIL_QUERY_PARAMETER_BEHAVIOR
+            ? key + "=" + encodeURIComponent("" + (value ?? ""))
+            : key,
+        );
       }
+      return result.join("&");
+    }
 
-      serialize(object: Serializable): string {
-        return this.configuration.serializer(object);
-      }
+    serialize(object: Serializable): string {
+      return this.configuration.serializer(object);
+    }
 
-      extract_options(
-        number_of_params: number,
-        args: OptionalRouteParameter[]
-      ): {
-        args: OptionalRouteParameter[];
-        options: RouteOptions;
-      } {
-        const last_el = args[args.length - 1];
-        if (
-          (args.length > number_of_params && last_el === 0) ||
-          (this.is_object(last_el) &&
-            !this.looks_like_serialized_model(last_el))
-        ) {
-          if (this.is_object(last_el)) {
-            delete last_el[this.configuration.special_options_key];
-          }
-          return {
-            args: args.slice(0, args.length - 1),
-            options: last_el as unknown as RouteOptions,
-          };
-        } else {
-          return { args, options: {} };
+    extract_options(
+      number_of_params: number,
+      args: OptionalRouteParameter[],
+    ): {
+      args: OptionalRouteParameter[];
+      options: RouteOptions;
+    } {
+      const last_el = args[args.length - 1];
+      if (
+        (args.length > number_of_params && last_el === 0) ||
+        (this.is_object(last_el) && !this.looks_like_serialized_model(last_el))
+      ) {
+        if (this.is_object(last_el)) {
+          delete last_el[this.configuration.special_options_key];
         }
+        return {
+          args: args.slice(0, args.length - 1),
+          options: last_el as unknown as RouteOptions,
+        };
+      } else {
+        return { args, options: {} };
       }
+    }
 
-      looks_like_serialized_model(
-        object: unknown
-      ): object is ModelRouteParameter {
-        return (
-          this.is_object(object) &&
-          !(this.configuration.special_options_key in object) &&
-          ("id" in object || "to_param" in object || "toParam" in object)
-        );
-      }
+    looks_like_serialized_model(
+      object: unknown,
+    ): object is ModelRouteParameter {
+      return (
+        this.is_object(object) &&
+        !(this.configuration.special_options_key in object) &&
+        ("id" in object || "to_param" in object || "toParam" in object)
+      );
+    }
 
-      path_identifier(object: QueryRouteParameter): string {
-        const result = this.unwrap_path_identifier(object);
-        return this.is_nullable(result) ||
-          (RubyVariables.DEPRECATED_FALSE_PARAMETER_BEHAVIOR &&
-            result === false)
-          ? ""
-          : "" + result;
-      }
+    path_identifier(object: QueryRouteParameter): string {
+      const result = this.unwrap_path_identifier(object);
+      return this.is_nullable(result) ||
+        (RubyVariables.DEPRECATED_FALSE_PARAMETER_BEHAVIOR && result === false)
+        ? ""
+        : "" + result;
+    }
 
-      unwrap_path_identifier(object: QueryRouteParameter): unknown {
-        let result: unknown = object;
-        if (!this.is_object(object)) {
-          return object;
-        }
-        if ("to_param" in object) {
-          result = object.to_param;
-        } else if ("toParam" in object) {
-          result = object.toParam;
-        } else if ("id" in object) {
-          result = object.id;
-        } else {
-          result = object;
-        }
-        return this.is_callable(result) ? result.call(object) : result;
-      }
+    unwrap_path_identifier(object: QueryRouteParameter): unknown {
+      let result: unknown = object;
+      if (!this.is_object(object)) {
+        return object;
+      }
+      if ("to_param" in object) {
+        result = object.to_param;
+      } else if ("toParam" in object) {
+        result = object.toParam;
+      } else if ("id" in object) {
+        result = object.id;
+      } else {
+        result = object;
+      }
+      return this.is_callable(result) ? result.call(object) : result;
+    }
 
-      partition_parameters(
-        parts: string[],
-        required_params: string[],
-        default_options: RouteParameters,
-        call_arguments: OptionalRouteParameter[]
-      ): {
-        keyword_parameters: KeywordUrlOptions;
-        query_parameters: RouteParameters;
-      } {
-        // eslint-disable-next-line prefer-const
-        let { args, options } = this.extract_options(
-          parts.length,
-          call_arguments
-        );
-        if (args.length > parts.length) {
-          throw new Error("Too many parameters provided for path");
-        }
-        let use_all_parts = args.length > required_params.length;
-        const parts_options: RouteParameters = {
-          ...this.configuration.default_url_options,
-        };
-        for (const key in options) {
-          const value = options[key];
-          if (!hasProp(options, key)) continue;
-          use_all_parts = true;
-          if (parts.includes(key)) {
-            parts_options[key] = value;
-          }
+    partition_parameters(
+      parts: string[],
+      required_params: string[],
+      default_options: RouteParameters,
+      call_arguments: OptionalRouteParameter[],
+    ): {
+      keyword_parameters: KeywordUrlOptions;
+      query_parameters: RouteParameters;
+    } {
+      let { args, options } = this.extract_options(
+        parts.length,
+        call_arguments,
+      );
+      if (args.length > parts.length) {
+        throw new Error("Too many parameters provided for path");
+      }
+      let use_all_parts = args.length > required_params.length;
+      const parts_options: RouteParameters = {
+        ...this.configuration.default_url_options,
+      };
+      for (const key in options) {
+        const value = options[key];
+        if (!hasProp(options, key)) continue;
+        use_all_parts = true;
+        if (parts.includes(key)) {
+          parts_options[key] = value;
         }
-        options = {
-          ...this.configuration.default_url_options,
-          ...default_options,
-          ...options,
-        };
+      }
+      options = {
+        ...this.configuration.default_url_options,
+        ...default_options,
+        ...options,
+      };
 
-        const keyword_parameters: KeywordUrlOptions = {};
-        let query_parameters: RouteParameters = {};
-        for (const key in options) {
-          if (!hasProp(options, key)) continue;
-          const value = options[key];
-          if (key === "params") {
-            if (this.is_object(value)) {
-              query_parameters = {
-                ...query_parameters,
-                ...(value as RouteParameters),
-              };
-            } else {
-              throw new Error("params value should always be an object");
-            }
-          } else if (this.is_reserved_option(key)) {
-            keyword_parameters[key] = value as any;
+      const keyword_parameters: KeywordUrlOptions = {};
+      let query_parameters: RouteParameters = {};
+      for (const key in options) {
+        if (!hasProp(options, key)) continue;
+        const value = options[key];
+        if (key === "params") {
+          if (this.is_object(value)) {
+            query_parameters = {
+              ...query_parameters,
+              ...(value as RouteParameters),
+            };
           } else {
-            if (
-              !this.is_nullable(value) &&
-              (value !== default_options[key] || required_params.includes(key))
-            ) {
-              query_parameters[key] = value;
-            }
+            throw new Error("params value should always be an object");
           }
-        }
-        const route_parts = use_all_parts ? parts : required_params;
-        let i = 0;
-        for (const part of route_parts) {
-          if (i < args.length) {
-            const value = args[i];
-            if (!hasProp(parts_options, part)) {
-              query_parameters[part] = value;
-              ++i;
-            }
+        } else if (this.is_reserved_option(key)) {
+          keyword_parameters[key] = value as any;
+        } else {
+          if (
+            !this.is_nullable(value) &&
+            (value !== default_options[key] || required_params.includes(key))
+          ) {
+            query_parameters[key] = value;
           }
         }
-        return { keyword_parameters, query_parameters };
       }
-
-      build_route(
-        parts: string[],
-        required_params: string[],
-        default_options: RouteParameters,
-        route: RouteTree,
-        absolute: boolean,
-        args: OptionalRouteParameter[]
-      ): string {
-        const { keyword_parameters, query_parameters } =
-          this.partition_parameters(
-            parts,
-            required_params,
-            default_options,
-            args
-          );
-
-        let { trailing_slash, anchor, script_name } = keyword_parameters;
-        const missing_params = required_params.filter(
-          (param) =>
-            !hasProp(query_parameters, param) ||
-            this.is_nullable(query_parameters[param])
-        );
-        if (missing_params.length) {
-          throw new ParametersMissing(...missing_params);
-        }
-        let result = this.get_prefix() + this.visit(route, query_parameters);
-        if (trailing_slash) {
-          result = result.replace(/(.*?)[/]?$/, "$1/");
-        }
-        const url_params = this.serialize(query_parameters);
-        if (url_params.length) {
-          result += "?" + url_params;
-        }
-        if (anchor) {
-          result += "#" + anchor;
-        }
-        if (script_name) {
-          const last_index = script_name.length - 1;
-          if (script_name[last_index] == "/" && result[0] == "/") {
-            script_name = script_name.slice(0, last_index);
+      const route_parts = use_all_parts ? parts : required_params;
+      let i = 0;
+      for (const part of route_parts) {
+        if (i < args.length) {
+          const value = args[i];
+          if (!hasProp(parts_options, part)) {
+            query_parameters[part] = value;
+            ++i;
           }
-          result = script_name + result;
-        }
-        if (absolute) {
-          result = this.route_url(keyword_parameters) + result;
-        }
-        return result;
-      }
-
-      visit(
-        route: RouteTree,
-        parameters: RouteParameters,
-        optional = false
-      ): string {
-        switch (route[0]) {
-          case NodeTypes.GROUP:
-            return this.visit(route[1], parameters, true);
-          case NodeTypes.CAT:
-            return this.visit_cat(route, parameters, optional);
-          case NodeTypes.SYMBOL:
-            return this.visit_symbol(route, parameters, optional);
-          case NodeTypes.STAR:
-            return this.visit_globbing(route[1], parameters, true);
-          case NodeTypes.LITERAL:
-          case NodeTypes.SLASH:
-          case NodeTypes.DOT:
-            return route[1];
-          default:
-            throw new Error("Unknown Rails node type");
         }
       }
+      return { keyword_parameters, query_parameters };
+    }
 
-      is_not_nullable<T>(object: T): object is NonNullable<T> {
-        return !this.is_nullable(object);
-      }
-
-      is_nullable(object: unknown): object is null | undefined {
-        return object === undefined || object === null;
-      }
+    build_route(
+      parts: string[],
+      required_params: string[],
+      default_options: RouteParameters,
+      route: RouteTree,
+      absolute: boolean,
+      args: OptionalRouteParameter[],
+    ): string {
+      const { keyword_parameters, query_parameters } =
+        this.partition_parameters(
+          parts,
+          required_params,
+          default_options,
+          args,
+        );
 
-      visit_cat(
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        [_type, left, right]: RouteNode<NodeTypes.CAT>,
-        parameters: RouteParameters,
-        optional: boolean
-      ): string {
-        const left_part = this.visit(left, parameters, optional);
-        let right_part = this.visit(right, parameters, optional);
-        if (
-          optional &&
-          ((this.is_optional_node(left[0]) && !left_part) ||
-            (this.is_optional_node(right[0]) && !right_part))
-        ) {
-          return "";
+      let { trailing_slash, anchor, script_name } = keyword_parameters;
+      const missing_params = required_params.filter(
+        (param) =>
+          !hasProp(query_parameters, param) ||
+          this.is_nullable(query_parameters[param]),
+      );
+      if (missing_params.length) {
+        throw new ParametersMissing(...missing_params);
+      }
+      let result = this.get_prefix() + this.visit(route, query_parameters);
+      if (trailing_slash) {
+        result = result.replace(/(.*?)[/]?$/, "$1/");
+      }
+      const url_params = this.serialize(query_parameters);
+      if (url_params.length) {
+        result += "?" + url_params;
+      }
+      if (anchor) {
+        result += "#" + anchor;
+      }
+      if (script_name) {
+        const last_index = script_name.length - 1;
+        if (script_name[last_index] == "/" && result[0] == "/") {
+          script_name = script_name.slice(0, last_index);
         }
-        // if left_part ends on '/' and right_part starts on '/'
-        if (left_part[left_part.length - 1] === "/" && right_part[0] === "/") {
-          // strip slash from right_part
-          // to prevent double slash
-          right_part = right_part.substring(1);
-        }
-        return left_part + right_part;
+        result = script_name + result;
       }
-
-      visit_symbol(
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        [_type, key]: RouteNode<NodeTypes.SYMBOL>,
-        parameters: RouteParameters,
-        optional: boolean
-      ): string {
-        const value = this.path_identifier(parameters[key]);
-        delete parameters[key];
-        if (value.length) {
-          return this.encode_segment(value);
-        }
-        if (optional) {
-          return "";
-        } else {
-          throw new ParametersMissing(key);
-        }
+      if (absolute) {
+        result = this.route_url(keyword_parameters) + result;
       }
+      return result;
+    }
 
-      encode_segment(segment: string): string {
-        if (segment.match(/^[a-zA-Z0-9-]$/)) {
-          // Performance optimization for 99% of cases
-          return segment;
-        }
-        return (segment.match(/./gu) || [])
-          .map((ch) => {
-            const code = ch.charCodeAt(0);
-            if (
-              UnescapedRanges.find(
-                (range) => code >= range[0] && code <= range[1]
-              ) ||
-              UnescapedSpecials.includes(code)
-            ) {
-              return ch;
-            } else {
-              return encodeURIComponent(ch);
-            }
-          })
-          .join("");
+    visit(
+      route: RouteTree,
+      parameters: RouteParameters,
+      optional = false,
+    ): string {
+      switch (route[0]) {
+        case NodeTypes.GROUP:
+          return this.visit(route[1], parameters, true);
+        case NodeTypes.CAT:
+          return this.visit_cat(route, parameters, optional);
+        case NodeTypes.SYMBOL:
+          return this.visit_symbol(route, parameters, optional);
+        case NodeTypes.STAR:
+          return this.visit_globbing(route[1], parameters, true);
+        case NodeTypes.LITERAL:
+        case NodeTypes.SLASH:
+        case NodeTypes.DOT:
+          return route[1];
+        default:
+          throw new Error("Unknown Rails node type");
       }
+    }
 
-      is_optional_node(node: NodeTypes): boolean {
-        return [NodeTypes.STAR, NodeTypes.SYMBOL, NodeTypes.CAT].includes(node);
-      }
+    is_not_nullable<T>(object: T): object is NonNullable<T> {
+      return !this.is_nullable(object);
+    }
 
-      build_path_spec(route: RouteTree, wildcard = false): string {
-        let key: string;
-        switch (route[0]) {
-          case NodeTypes.GROUP:
-            return `(${this.build_path_spec(route[1])})`;
-          case NodeTypes.CAT:
-            return (
-              this.build_path_spec(route[1]) + this.build_path_spec(route[2])
-            );
-          case NodeTypes.STAR:
-            return this.build_path_spec(route[1], true);
-          case NodeTypes.SYMBOL:
-            key = route[1];
-            if (wildcard) {
-              return (key.startsWith("*") ? "" : "*") + key;
-            } else {
-              return ":" + key;
-            }
-            break;
-          case NodeTypes.SLASH:
-          case NodeTypes.DOT:
-          case NodeTypes.LITERAL:
-            return route[1];
-          default:
-            throw new Error("Unknown Rails node type");
-        }
-      }
+    is_nullable(object: unknown): object is null | undefined {
+      return object === undefined || object === null;
+    }
 
-      visit_globbing(
-        route: RouteTree,
-        parameters: RouteParameters,
-        optional: boolean
-      ): string {
-        const key = route[1] as string;
-        let value = parameters[key];
-        delete parameters[key];
-        if (this.is_nullable(value)) {
-          return this.visit(route, parameters, optional);
-        }
-        if (this.is_array(value)) {
-          value = value.join("/");
-        }
-        const result = this.path_identifier(value as any);
-        return encodeURI(result);
-      }
+    visit_cat(
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      [_type, left, right]: RouteNode<NodeTypes.CAT>,
+      parameters: RouteParameters,
+      optional: boolean,
+    ): string {
+      const left_part = this.visit(left, parameters, optional);
+      let right_part = this.visit(right, parameters, optional);
+      if (
+        optional &&
+        ((this.is_optional_node(left[0]) && !left_part) ||
+          (this.is_optional_node(right[0]) && !right_part))
+      ) {
+        return "";
+      }
+      // if left_part ends on '/' and right_part starts on '/'
+      if (left_part[left_part.length - 1] === "/" && right_part[0] === "/") {
+        // strip slash from right_part
+        // to prevent double slash
+        right_part = right_part.substring(1);
+      }
+      return left_part + right_part;
+    }
 
-      get_prefix(): string {
-        const prefix = this.configuration.prefix;
-        return prefix.match("/$")
-          ? prefix.substring(0, prefix.length - 1)
-          : prefix;
+    visit_symbol(
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      [_type, key]: RouteNode<NodeTypes.SYMBOL>,
+      parameters: RouteParameters,
+      optional: boolean,
+    ): string {
+      const value = this.path_identifier(parameters[key]);
+      delete parameters[key];
+      if (value.length) {
+        return this.encode_segment(value);
+      }
+      if (optional) {
+        return "";
+      } else {
+        throw new ParametersMissing(key);
       }
+    }
 
-      route(
-        parts_table: PartsTable,
-        route_spec: RouteTree,
-        absolute = false
-      ): RouteHelper {
-        const required_params: string[] = [];
-        const parts: string[] = [];
-        const default_options: RouteParameters = {};
-        for (const [part, { r: required, d: value }] of Object.entries(
-          parts_table
-        )) {
-          parts.push(part);
-          if (required) {
-            required_params.push(part);
-          }
-          if (this.is_not_nullable(value)) {
-            default_options[part] = value;
+    encode_segment(segment: string): string {
+      if (segment.match(/^[a-zA-Z0-9-]$/)) {
+        // Performance optimization for 99% of cases
+        return segment;
+      }
+      return (segment.match(/./gu) || [])
+        .map((ch) => {
+          const code = ch.charCodeAt(0);
+          if (
+            UnescapedRanges.find(
+              (range) => code >= range[0] && code <= range[1],
+            ) ||
+            UnescapedSpecials.includes(code)
+          ) {
+            return ch;
+          } else {
+            return encodeURIComponent(ch);
           }
-        }
-        const result = (...args: OptionalRouteParameter[]): string => {
-          return this.build_route(
-            parts,
-            required_params,
-            default_options,
-            route_spec,
-            absolute,
-            args
+        })
+        .join("");
+    }
+
+    is_optional_node(node: NodeTypes): boolean {
+      return [NodeTypes.STAR, NodeTypes.SYMBOL, NodeTypes.CAT].includes(node);
+    }
+
+    build_path_spec(route: RouteTree, wildcard = false): string {
+      let key: string;
+      switch (route[0]) {
+        case NodeTypes.GROUP:
+          return `(${this.build_path_spec(route[1])})`;
+        case NodeTypes.CAT:
+          return (
+            this.build_path_spec(route[1]) + this.build_path_spec(route[2])
           );
-        };
-        result.requiredParams = () => required_params;
-        result.toString = () => {
-          return this.build_path_spec(route_spec);
-        };
-        return result as any;
+        case NodeTypes.STAR:
+          return this.build_path_spec(route[1], true);
+        case NodeTypes.SYMBOL:
+          key = route[1];
+          if (wildcard) {
+            return (key.startsWith("*") ? "" : "*") + key;
+          } else {
+            return ":" + key;
+          }
+          break;
+        case NodeTypes.SLASH:
+        case NodeTypes.DOT:
+        case NodeTypes.LITERAL:
+          return route[1];
+        default:
+          throw new Error("Unknown Rails node type");
       }
+    }
 
-      route_url(route_defaults: KeywordUrlOptions): string {
-        const hostname = route_defaults.host || this.current_host();
-        if (!hostname) {
-          return "";
-        }
-        const subdomain = route_defaults.subdomain
-          ? route_defaults.subdomain + "."
-          : "";
-        const protocol = route_defaults.protocol || this.current_protocol();
-        let port =
-          route_defaults.port ||
-          (!route_defaults.host ? this.current_port() : undefined);
-        port = port ? ":" + port : "";
-        return protocol + "://" + subdomain + hostname + port;
-      }
+    visit_globbing(
+      route: RouteTree,
+      parameters: RouteParameters,
+      optional: boolean,
+    ): string {
+      const key = route[1] as string;
+      let value = parameters[key];
+      delete parameters[key];
+      if (this.is_nullable(value)) {
+        return this.visit(route, parameters, optional);
+      }
+      if (this.is_array(value)) {
+        value = value.join("/");
+      }
+      const result = this.path_identifier(value as any);
+      return encodeURI(result);
+    }
 
-      current_host(): string {
-        return (isBrowser && window?.location?.hostname) || "";
-      }
+    get_prefix(): string {
+      const prefix = this.configuration.prefix;
+      return prefix.match("/$")
+        ? prefix.substring(0, prefix.length - 1)
+        : prefix;
+    }
 
-      current_protocol(): string {
-        return (
-          (isBrowser && window?.location?.protocol?.replace(/:$/, "")) || "http"
-        );
+    route(
+      parts_table: PartsTable,
+      route_spec: RouteTree,
+      absolute = false,
+    ): RouteHelper {
+      const required_params: string[] = [];
+      const parts: string[] = [];
+      const default_options: RouteParameters = {};
+      for (const [part, { r: required, d: value }] of Object.entries(
+        parts_table,
+      )) {
+        parts.push(part);
+        if (required) {
+          required_params.push(part);
+        }
+        if (this.is_not_nullable(value)) {
+          default_options[part] = value;
+        }
       }
+      const result = (...args: OptionalRouteParameter[]): string => {
+        return this.build_route(
+          parts,
+          required_params,
+          default_options,
+          route_spec,
+          absolute,
+          args,
+        );
+      };
+      result.requiredParams = () => required_params;
+      result.toString = () => {
+        return this.build_path_spec(route_spec);
+      };
+      return result as any;
+    }
 
-      current_port(): string {
-        return (isBrowser && window?.location?.port) || "";
-      }
+    route_url(route_defaults: KeywordUrlOptions): string {
+      const hostname = route_defaults.host || this.current_host();
+      if (!hostname) {
+        return "";
+      }
+      const subdomain = route_defaults.subdomain
+        ? route_defaults.subdomain + "."
+        : "";
+      const protocol = route_defaults.protocol || this.current_protocol();
+      let port =
+        route_defaults.port ||
+        (!route_defaults.host ? this.current_port() : undefined);
+      port = port ? ":" + port : "";
+      return protocol + "://" + subdomain + hostname + port;
+    }
 
-      is_object(value: unknown): value is Collection<unknown> {
-        return (
-          typeof value === "object" &&
-          Object.prototype.toString.call(value) === "[object Object]"
-        );
-      }
+    current_host(): string {
+      return (isBrowser && window?.location?.hostname) || "";
+    }
 
-      is_array<T>(object: unknown | T[]): object is T[] {
-        return object instanceof Array;
-      }
+    current_protocol(): string {
+      return (
+        (isBrowser && window?.location?.protocol?.replace(/:$/, "")) || "http"
+      );
+    }
 
-      is_callable(object: unknown): object is Function {
-        return typeof object === "function" && !!object.call;
-      }
+    current_port(): string {
+      return (isBrowser && window?.location?.port) || "";
+    }
 
-      is_reserved_option(key: unknown): key is ReservedOption {
-        return ReservedOptions.includes(key as any);
-      }
+    is_object(value: unknown): value is Collection<unknown> {
+      return (
+        typeof value === "object" &&
+        Object.prototype.toString.call(value) === "[object Object]"
+      );
+    }
 
-      configure(new_config: Partial<Configuration>): Configuration {
-        if (new_config.prefix) {
-          console.warn(
-            "JsRoutes configuration prefix option is deprecated in favor of default_url_options.script_name."
-          );
-        }
-        this.configuration = { ...this.configuration, ...new_config };
-        return this.configuration;
-      }
+    is_array<T>(object: unknown | T[]): object is T[] {
+      return object instanceof Array;
+    }
 
-      config(): Configuration {
-        return { ...this.configuration };
-      }
+    is_callable(object: unknown): object is Function {
+      return typeof object === "function" && !!object.call;
+    }
 
-      is_module_supported(name: ModuleType): boolean {
-        return ModuleReferences[name].isSupported();
-      }
+    is_reserved_option(key: unknown): key is ReservedOption {
+      return ReservedOptions.includes(key as any);
+    }
 
-      ensure_module_supported(name: ModuleType): void {
-        if (!this.is_module_supported(name)) {
-          throw new Error(`${name} is not supported by runtime`);
-        }
+    configure(new_config: Partial<Configuration>): Configuration {
+      if (new_config.prefix) {
+        console.warn(
+          "JsRoutes configuration prefix option is deprecated in favor of default_url_options.script_name.",
+        );
       }
+      this.configuration = { ...this.configuration, ...new_config };
+      return this.configuration;
+    }
 
-      define_module(
-        name: ModuleType,
-        module: RouterExposedMethods
-      ): RouterExposedMethods {
-        this.ensure_module_supported(name);
-        ModuleReferences[name].define(module);
-        return module;
-      }
+    config(): Configuration {
+      return { ...this.configuration };
     }
 
-    const utils = new UtilsClass();
+    is_module_supported(name: ModuleType): boolean {
+      return ModuleReferences[name].isSupported();
+    }
 
-    // We want this helper name to be short
-    const __jsr = {
-      r(
-        parts_table: PartsTable,
-        route_spec: RouteTree,
-        absolute?: boolean
-      ): RouteHelper {
-        return utils.route(parts_table, route_spec, absolute);
-      },
-    };
+    ensure_module_supported(name: ModuleType): void {
+      if (!this.is_module_supported(name)) {
+        throw new Error(`${name} is not supported by runtime`);
+      }
+    }
 
-    return utils.define_module(RubyVariables.MODULE_TYPE, {
-      ...__jsr,
-      configure: (config: Partial<Configuration>) => {
-        return utils.configure(config);
-      },
-      config: (): Configuration => {
-        return utils.config();
-      },
-      serialize: (object: Serializable): string => {
-        return utils.serialize(object);
-      },
-      ...RubyVariables.ROUTES_OBJECT,
-    });
+    define_module(
+      name: ModuleType,
+      module: RouterExposedMethods,
+    ): RouterExposedMethods {
+      this.ensure_module_supported(name);
+      ModuleReferences[name].define(module);
+      return module;
+    }
   }
-)();
+
+  const utils = new UtilsClass();
+
+  // We want this helper name to be short
+  const __jsr = {
+    r: utils.route.bind(utils),
+  };
+
+  return utils.define_module(RubyVariables.MODULE_TYPE, {
+    ...__jsr,
+    configure: utils.configure.bind(utils),
+    config: utils.config.bind(utils),
+    serialize: utils.serialize.bind(utils),
+    ...RubyVariables.ROUTES_OBJECT,
+  });
+})();