From 59ecb8f8d2ae9db85af1c8c400f305ccc09c4cb5 Mon Sep 17 00:00:00 2001
From: anshuman83-40 <292907463+anshuman83-40@users.noreply.github.com>
Date: Thu, 15 Oct 2026 22:10:05 +0530
Subject: [PATCH] Do not collapse consecutive slashes when normalizing URLs

a//b and a/b are different URLs which may serve different content, but
URL normalization rewrote any run of slashes in the path or querystring
as a single one. Keep them as they are, in both the Python normalization
and the JS (wombat) URL rewriting, which must produce the same ZIM paths.

get_document_uri computed the relative link with PurePosixPath, which
collapsed the slashes again; compute it segment by segment instead,
keeping empty segments, and prefix it with ./ when it would otherwise
start with / (making the link absolute or scheme-relative).

Fix #340
---
 CHANGELOG.md                                 |   1 +
 javascript/src/wombatSetup.js                |  10 +-
 javascript/test/wombatUrlRewriting.js        |  23 ++-
 src/zimscraperlib/rewriting/url_rewriting.py |  60 +++++---
 tests/rewriting/test_url_rewriting.py        | 152 ++++++++++++++++++-
 5 files changed, 211 insertions(+), 35 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1de7b951..e1f874c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Keep a rewritten `<script>`'s original `src` in `__wb_orig_src`, so wombat can return it from `getAttribute("src")` and bundlers that identify chunks by it (Next.js/Turbopack, Vite) still work (openzim/warc2zim#473)
 - Keep URL-encoded `#` characters of the path or querystring when rewriting document URIs, instead of dropping everything after them (#341)
 - Rewrite the `poster` attribute (e.g. of `<video>`) when rewriting HTML, like `src` and `href` (#339)
+- Do not collapse consecutive slashes `//` into a single `/` when normalizing URLs into ZIM paths, in both Python and JS rewriting (#340)
 
 ## [5.4.1] - 2026-07-31
 
diff --git a/javascript/src/wombatSetup.js b/javascript/src/wombatSetup.js
index 9aa84ca5..7c48eaee 100644
--- a/javascript/src/wombatSetup.js
+++ b/javascript/src/wombatSetup.js
@@ -63,12 +63,6 @@ export function hasAlreadyBeenRewritten(
   return false;
 }
 
-function removeSubsequentSlashes(value) {
-  // Remove all successive occurrences of a slash `/` in a given string
-  // E.g `val//ue` or `val///ue` or `val////ue` (and so on) are transformed into `value`
-  return value.replace(/\/\/+/g, '/');
-}
-
 export function urlRewriteFunction(
   current_url, // The current (real) url we are on, e.g. http://library.kiwix.org/content/myzim_yyyy-mm/www.example.com/index.html
   orig_host, // The host of the original url, e.g. www.example.com
@@ -186,8 +180,8 @@ export function urlRewriteFunction(
       : '?' + decodeURIComponent(absolute_url_parts.query).replaceAll('+', ' ');
 
   // combine all decoded parts to get the ZIM path
-  const zimPath =
-    decoded_host + removeSubsequentSlashes(decoded_path + decoded_query);
+  // (consecutive slashes are kept, just like in Python)
+  const zimPath = decoded_host + decoded_path + decoded_query;
 
   // apply the fuzzy rules to the ZIM path
   const fuzzifiedPath = applyFuzzyRules(zimPath);
diff --git a/javascript/test/wombatUrlRewriting.js b/javascript/test/wombatUrlRewriting.js
index 65a92486..64b397bf 100644
--- a/javascript/test/wombatUrlRewriting.js
+++ b/javascript/test/wombatUrlRewriting.js
@@ -84,6 +84,23 @@ test('simpleContentNoScheme', (t) => {
   );
 });
 
+test('consecutiveSlashesAreKept', (t) => {
+  t.is(
+    urlRewriteFunction(
+      t.context.currentUrl,
+      t.context.originalHost,
+      t.context.originalScheme,
+      t.context.originalUrl,
+      t.context.prefix,
+      'https://www.example.com/a///b',
+      undefined,
+      undefined,
+      undefined,
+    ),
+    'http://library.kiwix.org/content/myzim_yyyy-mm/www.example.com/a///b',
+  );
+});
+
 test('simpleContentEmptyPath', (t) => {
   t.is(
     urlRewriteFunction(
@@ -1159,7 +1176,7 @@ test('doubleSlash1', (t) => {
       undefined,
       undefined,
     ),
-    'http://library.kiwix.org/content/myzim_yyyy-mm/example.com/some/path/http%3A/example.com/some/path',
+    'http://library.kiwix.org/content/myzim_yyyy-mm/example.com/some/path/http%3A//example.com//some/path',
   );
 });
 
@@ -1176,7 +1193,7 @@ test('doubleSlash2', (t) => {
       undefined,
       undefined,
     ),
-    'http://library.kiwix.org/content/myzim_yyyy-mm/example.com/some/pa%3Fth/http%3A/example.com/some/path',
+    'http://library.kiwix.org/content/myzim_yyyy-mm/example.com/some/pa%3Fth/http%3A//example.com//some/path',
   );
 });
 
@@ -1193,6 +1210,6 @@ test('doubleSlash3', (t) => {
       undefined,
       undefined,
     ),
-    'http://library.kiwix.org/content/myzim_yyyy-mm/example.com/so%3Fme/pa%3Fth/http%3A/example.com/some/path',
+    'http://library.kiwix.org/content/myzim_yyyy-mm/example.com/so%3Fme/pa%3Fth/http%3A//example.com//some/path',
   );
 });
diff --git a/src/zimscraperlib/rewriting/url_rewriting.py b/src/zimscraperlib/rewriting/url_rewriting.py
index 69822fab..426f046b 100644
--- a/src/zimscraperlib/rewriting/url_rewriting.py
+++ b/src/zimscraperlib/rewriting/url_rewriting.py
@@ -42,7 +42,6 @@
 
 import re
 from dataclasses import dataclass
-from pathlib import PurePosixPath
 from typing import ClassVar
 from urllib.parse import quote, unquote, urljoin, urlsplit
 
@@ -321,17 +320,19 @@ def get_document_uri(self, item_path: ZimPath, item_fragment: str) -> str:
         item_url = item_parts.path
         if item_parts.query:
             item_url += "?" + item_parts.query
-        relative_path = str(
-            PurePosixPath(item_url).relative_to(
-                (
-                    PurePosixPath(self.article_path.value)
-                    if self.article_path.value.endswith("/")
-                    else PurePosixPath(self.article_path.value).parent
-                ),
-                walk_up=True,
-            )
+        # drop `.` segments of the article path, as PurePosixPath used to do
+        article_path = "/".join(
+            part for part in self.article_path.value.split("/") if part != "."
+        )
+        article_dir = (
+            article_path.removesuffix("/")
+            if article_path.endswith("/")
+            else article_path.rpartition("/")[0]
+        )
+        relative_path = ArticleUrlRewriter._relative_path(
+            item_url.removesuffix("/"), article_dir
         )
-        # relative_to removes a potential last '/' in the path, we add it back
+        # the last '/' of the path has been removed above, we add it back
         if item_path.value.endswith("/"):
             relative_path += "/"
 
@@ -340,6 +341,30 @@ def get_document_uri(self, item_path: ZimPath, item_fragment: str) -> str:
             f"{'#' + item_fragment if item_fragment else ''}"
         )
 
+    @classmethod
+    def _relative_path(cls, path: str, start: str) -> str:
+        """Relative path from directory `start` to `path`, walking up if needed
+
+        Unlike `PurePosixPath.relative_to`, empty segments are kept, so that
+        consecutive slashes in a ZIM path survive in the relative path.
+        """
+        path_parts = [part for part in path.split("/") if part != "."]
+        start_parts = (
+            [part for part in start.split("/") if part != "."] if start else []
+        )
+        common = 0
+        for path_part, start_part in zip(path_parts, start_parts, strict=False):
+            if path_part != start_part:
+                break
+            common += 1
+        parts = [".."] * (len(start_parts) - common) + path_parts[common:]
+        relative_path = "/".join(parts) or "."
+        # a leading empty segment would make the link absolute (`/b`) or
+        # scheme-relative (`//b`); `./` keeps it relative to the current directory
+        if relative_path.startswith("/"):
+            relative_path = "./" + relative_path
+        return relative_path
+
     @classmethod
     def apply_additional_rules(cls, uri: HttpUrl | str) -> str:
         """Apply additional rules on a URL or relative path
@@ -429,17 +454,10 @@ def normalize(cls, url: HttpUrl) -> ZimPath:
         else:
             query = ""
 
+        # consecutive slashes are kept as they are: `a//b` and `a/b` are different URLs
+        # which may serve different content
         fuzzified_url = ArticleUrlRewriter.apply_additional_rules(
-            f"{hostname}{ArticleUrlRewriter._remove_subsequent_slashes(path)}{ArticleUrlRewriter._remove_subsequent_slashes(query)}"
+            f"{hostname}{path}{query}"
         )
 
         return ZimPath(fuzzified_url)
-
-    @classmethod
-    def _remove_subsequent_slashes(cls, value: str) -> str:
-        """Remove all successive occurence of a slash `/` in a given string
-
-        E.g `val//ue` or `val///ue` or `val////ue` (and so on) are transformed into
-        `value`
-        """
-        return re.sub(r"//+", "/", value)
diff --git a/tests/rewriting/test_url_rewriting.py b/tests/rewriting/test_url_rewriting.py
index 24690848..b6261571 100644
--- a/tests/rewriting/test_url_rewriting.py
+++ b/tests/rewriting/test_url_rewriting.py
@@ -1,3 +1,5 @@
+from urllib.parse import unquote, urlsplit
+
 import pytest
 
 from zimscraperlib.rewriting.url_rewriting import (
@@ -47,16 +49,18 @@ class TestNormalize:
             ("http://example.com/#anchor1", "example.com/"),
             (
                 "http://example.com/some/path/http://example.com//some/path",
-                "example.com/some/path/http:/example.com/some/path",
+                "example.com/some/path/http://example.com//some/path",
             ),
             (
                 "http://example.com/some/pa?th/http://example.com//some/path",
-                "example.com/some/pa?th/http:/example.com/some/path",
+                "example.com/some/pa?th/http://example.com//some/path",
             ),
             (
                 "http://example.com/so?me/pa?th/http://example.com//some/path",
-                "example.com/so?me/pa?th/http:/example.com/some/path",
+                "example.com/so?me/pa?th/http://example.com//some/path",
             ),
+            ("http://example.com/a///b", "example.com/a///b"),
+            ("http://example.com/a//b?c=d//e", "example.com/a//b?c=d//e"),
             ("http://example.com/resource?", "example.com/resource"),
             ("http://example.com/resource#", "example.com/resource"),
             ("http://user@example.com/resource", "example.com/resource"),
@@ -587,6 +591,121 @@ def test_relative_url(
             == expected_rewrite_result
         )
 
+    @pytest.mark.parametrize(
+        "article_url, original_content_url, expected_rewrite_result",
+        [
+            (
+                "https://example.com/index.html",
+                "https://example.com/a///b",
+                RewriteResult(
+                    "https://example.com/a///b",
+                    "a///b",
+                    ZimPath("example.com/a///b"),
+                ),
+            ),
+            (
+                "https://example.com/index.html",
+                "https://example.com/p?q=x//y",
+                RewriteResult(
+                    "https://example.com/p?q=x//y",
+                    "p%3Fq=x//y",
+                    ZimPath("example.com/p?q=x//y"),
+                ),
+            ),
+            (
+                "https://example.com/index.html",
+                "https://example.com/a//b/",
+                RewriteResult(
+                    "https://example.com/a//b/",
+                    "a//b/",
+                    ZimPath("example.com/a//b/"),
+                ),
+            ),
+            (
+                "https://example.com/x//y/page.html",
+                "https://example.com/x//y/other.html",
+                RewriteResult(
+                    "https://example.com/x//y/other.html",
+                    "other.html",
+                    ZimPath("example.com/x//y/other.html"),
+                ),
+            ),
+            (
+                "https://example.com/x//y/page.html",
+                "https://example.com/x//z.html",
+                RewriteResult(
+                    "https://example.com/x//z.html",
+                    "../z.html",
+                    ZimPath("example.com/x//z.html"),
+                ),
+            ),
+            (
+                "https://example.com/x//y/page.html",
+                "/a.html",
+                RewriteResult(
+                    "https://example.com/a.html",
+                    "../../../a.html",
+                    ZimPath("example.com/a.html"),
+                ),
+            ),
+        ],
+    )
+    def test_relative_url_keeps_consecutive_slashes(
+        self,
+        article_url: str,
+        original_content_url: str,
+        expected_rewrite_result: RewriteResult,
+    ):
+        """The link must point to the ZIM path, consecutive slashes included"""
+        rewriter = ArticleUrlRewriter(article_url=HttpUrl(article_url))
+        assert (
+            rewriter(original_content_url, base_href=None, rewrite_all_url=True)
+            == expected_rewrite_result
+        )
+
+    @pytest.mark.parametrize(
+        "article_url, original_content_url, expected_rewritten_url",
+        [
+            # leading empty segments must not make the link absolute (`/b`) or
+            # scheme-relative (`//b`)
+            ("https://example.com/index.html", "https://example.com//b", ".//b"),
+            ("https://example.com/index.html", "https://example.com///b", ".///b"),
+            # empty segment right after the shared directory
+            ("https://example.com/a/index.html", "https://example.com/a//b", ".//b"),
+            (
+                "https://example.com/a/b/index.html",
+                "https://example.com//c",
+                "../..//c",
+            ),
+            ("https://example.com/index.html", "https://example.com/a///b", "a///b"),
+            ("https://example.com/index.html", "https://example.com/p?q=x//y", None),
+            ("https://example.com/index.html", "https://example.com/a//b/", "a//b/"),
+            (
+                "https://example.com/x//y/page.html",
+                "https://example.com/x//z.html",
+                None,
+            ),
+            ("https://example.com/x//y/page.html", "https://example.com/a.html", None),
+        ],
+    )
+    def test_relative_url_round_trip(
+        self,
+        article_url: str,
+        original_content_url: str,
+        expected_rewritten_url: str | None,
+    ):
+        """Resolving the rewritten link from the article gives back its ZIM path"""
+        rewriter = ArticleUrlRewriter(article_url=HttpUrl(article_url))
+        result = rewriter(original_content_url, base_href=None, rewrite_all_url=True)
+        if expected_rewritten_url is not None:
+            assert result.rewriten_url == expected_rewritten_url
+        assert result.zim_path is not None
+        assert not result.rewriten_url.startswith("/")
+        assert (
+            unquote(_resolve_relative_reference(article_url, result.rewriten_url))
+            == result.zim_path.value
+        )
+
     @pytest.mark.parametrize(
         "article_url, original_content_url, expected_rewrite_result, know_paths, "
         "rewrite_all_url",
@@ -1144,3 +1263,30 @@ def test_zim_path_hash(self):
     def test_zim_path_str(self):
         assert str(ZimPath("content/index.html")) == "ZimPath(content/index.html)"
         assert f"{ZimPath('content/index.html')}" == "ZimPath(content/index.html)"
+
+
+def _resolve_relative_reference(base_url: str, reference: str) -> str:
+    """Resolve a relative-path reference as browsers do (RFC 3986 section 5.2)
+
+    Unlike `urllib.parse.urljoin`, empty path segments are kept. Returns the host
+    and path of the resolved URL, i.e. the form of a ZIM path.
+    """
+    base = urlsplit(base_url)
+    path = base.path.rpartition("/")[0] + "/" + reference.partition("#")[0]
+    output: list[str] = []
+    while path:
+        if path.startswith(("../", "./")):
+            path = path.partition("/")[2]
+        elif path.startswith("/./") or path == "/.":
+            path = "/" + path[3:]
+        elif path.startswith("/../") or path == "/..":
+            path = "/" + path[4:]
+            if output:
+                output.pop()
+        elif path in (".", ".."):
+            path = ""
+        else:
+            end = path.find("/", 1)
+            segment, path = (path, "") if end == -1 else (path[:end], path[end:])
+            output.append(segment)
+    return f"{base.netloc}{''.join(output)}"