rx-player 4.2.0-dev.2024090500 → 4.2.0-dev.2024091000

package/src/compat/__tests__/can_reuse_media_keys.test.ts

@@ -8,7 +8,12 @@ describe("Compat - canReuseMediaKeys", () => {
 
   it("should return true on most browsers", async () => {
     vi.doMock("../browser_detection", () => {
-      return { isWebOs: false, isPhilipsNetTv: false, isPanasonic: false };
+      return {
+        isA1KStb40xx: false,
+        isWebOs: false,
+        isPhilipsNetTv: false,
+        isPanasonic: false,
+      };
     });
     const canReuseMediaKeys = (await vi.importActual("../can_reuse_media_keys.ts"))
       .default as typeof ICanReuseMediaKeys;
@@ -18,6 +23,7 @@ describe("Compat - canReuseMediaKeys", () => {
   it("should return false on WebOs", async () => {
     vi.doMock("../browser_detection", () => {
       return {
+        isA1KStb40xx: false,
         isWebOs: true,
         isWebOs2022: false,
         isPanasonic: false,
@@ -32,6 +38,7 @@ describe("Compat - canReuseMediaKeys", () => {
   it("should return false on Panasonic", async () => {
     vi.doMock("../browser_detection", () => {
       return {
+        isA1KStb40xx: false,
         isWebOs: false,
         isWebOs2022: false,
         isPanasonic: true,
@@ -46,6 +53,7 @@ describe("Compat - canReuseMediaKeys", () => {
   it("should return false on Philips' NETTV", async () => {
     vi.doMock("../browser_detection", () => {
       return {
+        isA1KStb40xx: false,
         isWebOs: false,
         isWebOs2022: false,
         isPanasonic: false,
@@ -56,4 +64,19 @@ describe("Compat - canReuseMediaKeys", () => {
       .default as typeof ICanReuseMediaKeys;
     expect(canReuseMediaKeys()).toBe(false);
   });
+
+  it("should return false on A1 KSTB 40xxx", async () => {
+    vi.doMock("../browser_detection", () => {
+      return {
+        isA1KStb40xx: true,
+        isWebOs: false,
+        isWebOs2022: false,
+        isPanasonic: false,
+        isPhilipsNetTv: false,
+      };
+    });
+    const canReuseMediaKeys = (await vi.importActual("../can_reuse_media_keys.ts"))
+      .default as typeof ICanReuseMediaKeys;
+    expect(canReuseMediaKeys()).toBe(false);
+  });
 });

package/src/compat/browser_detection.ts

@@ -79,6 +79,9 @@ let isPlayStation5 = false;
 /** `true` for the Xbox game consoles. */
 let isXbox = false;
 
+/** `true` for specific A1 STB: KSTB 40xx from Kaon Media. */
+let isA1KStb40xx = false;
+
 (function findCurrentBrowser(): void {
   if (isNode) {
     return;
@@ -167,24 +170,30 @@ let isXbox = false;
     isPanasonic = true;
   } else if (navigator.userAgent.indexOf("Xbox") !== -1) {
     isXbox = true;
+  } else if (navigator.userAgent.indexOf("Model/a1-kstb40xx")) {
+    isA1KStb40xx = true;
   }
 })();
 
 export {
+  // browsers
   isEdgeChromium,
+  isFirefox,
   isIE11,
   isIEOrEdge,
-  isFirefox,
+  isSafariDesktop,
+  isSafariMobile,
+
+  // specific devices
+  isA1KStb40xx,
   isPanasonic,
   isPhilipsNetTv,
   isPlayStation4,
   isPlayStation5,
-  isXbox,
-  isSafariDesktop,
-  isSafariMobile,
   isSamsungBrowser,
   isTizen,
   isWebOs,
   isWebOs2021,
   isWebOs2022,
+  isXbox,
 };

package/src/compat/can_reuse_media_keys.ts

@@ -1,4 +1,4 @@
-import { isPanasonic, isPhilipsNetTv, isWebOs } from "./browser_detection";
+import { isA1KStb40xx, isPanasonic, isPhilipsNetTv, isWebOs } from "./browser_detection";
 
 /**
  * Returns `true` if a `MediaKeys` instance (the  `Encrypted Media Extension`
@@ -11,9 +11,13 @@ import { isPanasonic, isPhilipsNetTv, isWebOs } from "./browser_detection";
  *     HTMLMediaElement.
  *   - (2024-08-23): Seen on Philips 2024 and 2023 in:
  *     https://github.com/canalplus/rx-player/issues/1464
+ *   - (2024-09-04): Another case seen on an "A1" set-top box model made by
+ *     Kaonmedia we will call the KSTB40xx.
+ *     It may share the problematic with other devices, but we have only seen
+ *     the problem on this one for now.
  *
  * @returns {boolean}
  */
 export default function canReuseMediaKeys(): boolean {
-  return !isWebOs && !isPhilipsNetTv && !isPanasonic;
+  return !isWebOs && !isPhilipsNetTv && !isPanasonic && !isA1KStb40xx;
 }

package/src/core/cmcd/cmcd_data_builder.ts

@@ -16,6 +16,7 @@ import createUuid from "../../utils/create_uuid";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import type { IRange } from "../../utils/ranges";
 import TaskCanceller from "../../utils/task_canceller";
+import { getRelativeUrl } from "../../utils/url-utils";
 
 /**
  * `rtp`, for "REQUESTED_MAXIMUM_THROUGHPUT", indicates the maximum throughput
@@ -44,6 +45,18 @@ export interface ICmcdSegmentInfo {
   representation: IRepresentation;
   /** Segment metadata linked to the wanted segment. */
   segment: ISegment;
+  /**
+   * Optional next segment that may be requested after this one.
+   * Should only be set (to something else than `undefined`) if that following
+   * segment is part of the same `Representation`.
+   *
+   * This information is used to produce the "next object request" and "next
+   * range request" part of the CMCD payload, used for segment prefetching.
+   *
+   * If `null` no segment will be requested next for now.
+   * If `undefined` we do not know which next segment will be requested.
+   */
+  nextSegment: ISegment | null | undefined;
 }
 
 /**
@@ -221,7 +234,6 @@ export default class CmcdDataBuilder {
     const props = this._getCommonCmcdData(this._lastThroughput[content.adaptation.type]);
     props.br = Math.round(content.representation.bitrate / 1000);
     props.d = Math.round(content.segment.duration * 1000);
-    // TODO nor (next object request) and nrr (next range request)
 
     switch (content.adaptation.type) {
       case "video":
@@ -238,6 +250,33 @@ export default class CmcdDataBuilder {
       props.ot = "i";
     }
 
+    if (
+      !isNullOrUndefined(content.nextSegment) &&
+      content.segment.url !== null &&
+      content.nextSegment.url !== null
+    ) {
+      // We add a special case for some initialization segment which need
+      // multiple byte-ranges to fully request, as the `CmcdDataBuilder`
+      // is not supposed to keep track of how the requesting part of the
+      // RxPlayer actually perform its multi-byte-range requests
+      if (!content.nextSegment.isInit || content.nextSegment.indexRange === undefined) {
+        const currSegmentUrl = content.segment.url;
+        const nextSegmentUrl = content.nextSegment.url;
+        const relativeUrl = getRelativeUrl(currSegmentUrl, nextSegmentUrl);
+        if (relativeUrl !== null) {
+          if (relativeUrl !== ".") {
+            props.nor = encodeURIComponent(relativeUrl);
+          }
+          if (content.nextSegment.range !== undefined) {
+            props.nrr = String(content.nextSegment.range[0]) + "-";
+            if (isFinite(content.nextSegment.range[1])) {
+              props.nrr += String(content.nextSegment.range[1]);
+            }
+          }
+        }
+      }
+    }
+
     let precizeBufferLengthMs;
     if (
       lastObservation !== undefined &&
@@ -355,7 +394,7 @@ export default class CmcdDataBuilder {
     };
 
     const addStringProperty = (
-      prop: "cid" | "sid",
+      prop: "cid" | "sid" | "nor" | "nrr",
       headerName: keyof typeof headers,
     ): void => {
       const val = props[prop];
@@ -384,6 +423,8 @@ export default class CmcdDataBuilder {
     addNumberProperty("d", "object");
     addNumberProperty("dl", "request");
     addNumberProperty("mtp", "request");
+    addStringProperty("nor", "request");
+    addStringProperty("nrr", "request");
     addTokenProperty("ot", "object");
     addNumberProperty("pr", "session");
     addNumberProperty("rtp", "status");
@@ -518,6 +559,31 @@ interface ICmcdProperties {
    * In kbps.
    */
   mtp?: number | undefined;
+  /**
+   * Next Object Request (nor)
+   * Relative path of the next object to be requested.
+   * This can be used to trigger pre-fetching by the CDN.
+   * This MUST be a path relative to the current request.
+   * This string MUST be URLEncoded.
+   * The client SHOULD NOT depend upon any pre-fetch action being taken - it is
+   * merely a request for such a pre-fetch to take place.
+   */
+  nor?: string | undefined;
+  /**
+   * Next Range Request (nrr)
+   * If the next request will be a partial object request, then this string
+   * denotes the byte range to be requested. If the ‘nor’ field is not set, then
+   * the object is assumed to match the object currently being requested.
+   * The client SHOULD NOT depend upon any pre-fetch action being taken – it is
+   * merely a request for such a pre-fetch to take place. Formatting is similar
+   * to the HTTP Range header, except that the unit MUST be ‘byte’, the ‘Range:’
+   * prefix is NOT required and specifying multiple ranges is NOT allowed.
+   * Valid combinations are:
+   * "<range-start>-"
+   * "<range-start>-<range-end>"
+   * "-<suffix-length>"
+   */
+  nrr?: string | undefined;
   /**
    * Object type (ot)
    * The media type of the current object being requested:

package/src/core/fetchers/segment/segment_fetcher.ts

@@ -427,11 +427,35 @@ export interface ISegmentFetcherCallbacks<TSegmentDataType> {
 
 /** Content used by the segment loader as a context to load a new segment. */
 export interface ISegmentLoaderContent {
+  /** Manifest metadata linked to the wanted segment. */
   manifest: IManifest;
+  /** Period metadata linked to the wanted segment. */
   period: IPeriod;
+  /** Adaptation metadata linked to the wanted segment. */
   adaptation: IAdaptation;
+  /** Representation metadata linked to the wanted segment. */
   representation: IRepresentation;
+  /** Segment metadata linked to the wanted segment. */
   segment: ISegment;
+  /**
+   * Optional next segment that may be requested after this one.
+   * Should only be set (to something else than `undefined`) if that following
+   * segment is part of the same `Representation`.
+   *
+   * This is only used as an hint, finally requesting another segment after this
+   * one due to unexpected changes (e.g. bandwidth update, track change etc.) is
+   * OK.
+   *
+   * This information is then used mostly for matters related yet not required
+   * by requests, such as CMCD reporting. In scenarios when it's not
+   * straightforward to guess which segment will be requested after this one,
+   * this property can be ignored (set to `undefined`).
+   *
+   * If `null` no segment will be requested next for now.
+   *
+   * If `undefined` we do not know which next segment will be requested.
+   */
+  nextSegment: ISegment | null | undefined;
 }
 
 /**

package/src/core/fetchers/segment/segment_queue.ts

@@ -255,11 +255,10 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
     }
 
     const { downloadQueue, content, initSegmentInfoRef, currentCanceller } = contentInfo;
-    const { segmentQueue } = downloadQueue.getValue();
-    const currentNeededSegment = segmentQueue[0];
-    const recursivelyRequestSegments = (
-      startingSegment: IQueuedSegment | undefined,
-    ): void => {
+
+    const recursivelyRequestSegments = (): void => {
+      const { segmentQueue } = downloadQueue.getValue();
+      const startingSegment = segmentQueue[0];
       if (currentCanceller !== null && currentCanceller.isUsed()) {
         contentInfo.mediaSegmentRequest = null;
         return;
@@ -276,7 +275,10 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
           : canceller.linkToSignal(currentCanceller.signal);
 
       const { segment, priority } = startingSegment;
-      const context = objectAssign({ segment }, content);
+      const context = objectAssign(
+        { segment, nextSegment: segmentQueue[1]?.segment },
+        content,
+      );
 
       /**
        * If `true` , the current task has either errored, finished, or was
@@ -318,7 +320,7 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
           lastQueue.shift();
         }
         isComplete = true;
-        recursivelyRequestSegments(lastQueue[0]);
+        recursivelyRequestSegments();
       };
 
       /** Scheduled actual segment request. */
@@ -422,7 +424,7 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
 
       contentInfo.mediaSegmentRequest = { segment, priority, request, canceller };
     };
-    recursivelyRequestSegments(currentNeededSegment);
+    recursivelyRequestSegments();
   }
 
   /**
@@ -449,7 +451,7 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
         ? noop
         : canceller.linkToSignal(contentInfo.currentCanceller.signal);
     const { segment, priority } = queuedInitSegment;
-    const context = objectAssign({ segment }, content);
+    const context = objectAssign({ segment, nextSegment: undefined }, content);
 
     /**
      * If `true` , the current task has either errored, finished, or was

package/src/core/main/worker/worker_main.ts

@@ -884,6 +884,10 @@ function loadOrReloadPreparedContent(
         );
       },
       (err: unknown) => {
+        if (TaskCanceller.isCancellationError(err)) {
+          log.info("WP: A reloading operation was cancelled");
+          return;
+        }
         sendMessage({
           type: WorkerMessageType.Error,
           contentId,

package/src/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.ts

@@ -207,7 +207,10 @@ export default class VideoThumbnailLoader {
           lastRepInfo.initSegmentUniqueId = null;
           return sourceBufferInterface;
         }
-        const segmentInfo = objectAssign({ segment: initSegment }, content);
+        const segmentInfo = objectAssign(
+          { segment: initSegment, nextSegment: undefined },
+          content,
+        );
         await loadAndPushSegment(
           segmentInfo,
           sourceBufferInterface,
@@ -272,7 +275,10 @@ export default class VideoThumbnailLoader {
             const unlinkSignal = requestCanceller.linkToSignal(
               lastRepInfo.cleaner.signal,
             );
-            const segmentInfo = objectAssign({ segment }, content);
+            const segmentInfo = objectAssign(
+              { segment, nextSegment: undefined },
+              content,
+            );
             const prom = loadAndPushSegment(
               segmentInfo,
               sourceBufferInterface,

package/src/main_thread/api/public_api.ts

@@ -409,7 +409,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.2.0-dev.2024090500";
+    this.version = /* PLAYER_VERSION */ "4.2.0-dev.2024091000";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -3313,7 +3313,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.2.0-dev.2024090500";
+Player.version = /* PLAYER_VERSION */ "4.2.0-dev.2024091000";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/parsers/manifest/dash/common/parse_mpd.ts

@@ -20,7 +20,7 @@ import type { IManifest } from "../../../../manifest";
 import arrayFind from "../../../../utils/array_find";
 import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
-import { getFilenameIndexInUrl } from "../../../../utils/resolve_url";
+import { getFilenameIndexInUrl } from "../../../../utils/url-utils";
 import type { IParsedManifest } from "../../types";
 import type {
   IMPDIntermediateRepresentation,

package/src/parsers/manifest/dash/common/resolve_base_urls.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import resolveURL from "../../../../utils/resolve_url";
+import { resolveURL } from "../../../../utils/url-utils";
 import type { IBaseUrlIntermediateRepresentation } from "../node_parser_types";
 
 export interface IResolvedBaseUrl {

package/src/parsers/manifest/metaplaylist/metaplaylist_parser.ts

@@ -22,7 +22,7 @@ import type { ITrackType } from "../../../public_types";
 import idGenerator from "../../../utils/id_generator";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
-import { getFilenameIndexInUrl } from "../../../utils/resolve_url";
+import { getFilenameIndexInUrl } from "../../../utils/url-utils";
 import type {
   IParsedAdaptation,
   IParsedAdaptations,

package/src/parsers/manifest/smooth/create_parser.ts

@@ -23,8 +23,8 @@ import isNonEmptyString from "../../../utils/is_non_empty_string";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import objectAssign from "../../../utils/object_assign";
-import { getFilenameIndexInUrl } from "../../../utils/resolve_url";
 import { hexToBytes } from "../../../utils/string_parsing";
+import { getFilenameIndexInUrl } from "../../../utils/url-utils";
 import { createBox } from "../../containers/isobmff";
 import type {
   IParsedAdaptation,

package/src/transports/dash/construct_segment_url.ts

@@ -16,7 +16,7 @@
 
 import type { ISegment } from "../../manifest";
 import type { ICdnMetadata } from "../../parsers/manifest";
-import resolveURL from "../../utils/resolve_url";
+import { resolveURL } from "../../utils/url-utils";
 
 export default function constructSegmentUrl(
   wantedCdn: ICdnMetadata | null,

package/src/transports/smooth/utils.ts

@@ -16,7 +16,7 @@
 
 import type { ISegment, IRepresentation } from "../../manifest";
 import type { ICdnMetadata } from "../../parsers/manifest";
-import resolveURL from "../../utils/resolve_url";
+import { resolveURL } from "../../utils/url-utils";
 
 /**
  * Returns `true` if the given Representation refers to segments in an MP4

package/src/utils/__tests__/{resolve_url.test.ts → url-utils.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import resolveURL, { getFilenameIndexInUrl } from "../resolve_url";
+import { getFilenameIndexInUrl, getRelativeUrl, resolveURL } from "../url-utils";
 
 describe(`utils - resolveURL ${resolveURL.name}`, () => {
   it("should return an empty string if no argument is given", () => {
@@ -155,3 +155,150 @@ describe("utils - getFilenameIndexInUrl", () => {
     expect(getFilenameIndexInUrl("https://ww/rr/d/?test/toto/efewf/ffe/")).toEqual(16);
   });
 });
+
+describe("utils - getRelativeUrl", () => {
+  it("should succeed on two absolute URLs on the same domain", () => {
+    expect(
+      getRelativeUrl("https://foo.com/foo/bar/cil/", "https://foo.com/foo/bar/cil/diub"),
+    ).toEqual("diub");
+    expect(
+      getRelativeUrl(
+        "https://foo.com/foo/bar/cil/",
+        "https://foo.com/foo/bar/cil/diub/emp",
+      ),
+    ).toEqual("diub/emp");
+    expect(
+      getRelativeUrl(
+        "https://foo.com/foo/bar/cil/diub/emp/",
+        "https://foo.com/foo/bar/cil/f/g/h/i",
+      ),
+    ).toEqual("../../f/g/h/i");
+
+    expect(
+      getRelativeUrl(
+        "https://foo.com/foo/bar/cil/emp",
+        "https://foo.com/foo/bar/cil/emp",
+      ),
+    ).toEqual("");
+  });
+
+  it("should handle it right when one of the input is just a domain name without a path", () => {
+    expect(
+      getRelativeUrl(
+        "http://github.com" /** Without a starting slash */,
+        "http://github.com/rx-player",
+      ),
+    ).toBe("/rx-player");
+    expect(
+      getRelativeUrl(
+        "http://github.com/rx-player/",
+        "http://github.com" /** Without a starting slash */,
+      ),
+    ).toBe("..");
+  });
+
+  it("should handle it right when one of the input has a path of length 0", () => {
+    expect(getRelativeUrl("http://github.com/", "http://github.com/rx-player")).toBe(
+      "rx-player",
+    );
+    expect(
+      getRelativeUrl(
+        "http://github.com/rx-player/",
+        "http://github.com" /** Without a starting slash */,
+      ),
+    ).toBe("..");
+  });
+
+  it("should fail if scheme is different", () => {
+    expect(
+      getRelativeUrl("http://foo.com/foo/bar/cil/emp", "https://foo.com/foo/bar/cil/emp"),
+    ).toEqual(null);
+
+    expect(
+      getRelativeUrl("https://foo.com/foo/bar/cil/emp", "http://foo.com/foo/bar/cil/emp"),
+    ).toEqual(null);
+  });
+
+  it("should fail if domain is different", () => {
+    expect(
+      getRelativeUrl(
+        "https://bar.com/foo/bar/cil/emp",
+        "https://foo.com/foo/bar/cil/emp",
+      ),
+    ).toEqual(null);
+  });
+
+  it("should fail if one anounce a domain but not the other", () => {
+    expect(getRelativeUrl("https://foo.com/foo/bar/cil/diub/emp", "/a")).toEqual(null);
+
+    expect(getRelativeUrl("../url", "https://foo.com")).toEqual(null);
+  });
+
+  it('should output "." if the URL points to the same file', () => {
+    expect(getRelativeUrl("../url", "../url")).toEqual("");
+    expect(
+      getRelativeUrl(
+        "https://foo.com/foo/bar/cil/diub/emp",
+        "https://foo.com/foo/bar/cil/diub/emp",
+      ),
+    ).toEqual("");
+    expect(
+      getRelativeUrl(
+        "https://foo.com/foo/bar/cil/diub/emp",
+        "https://foo.com/foo/bar/../bar/cil/diub/emp",
+      ),
+    ).toEqual("");
+  });
+
+  it("should succeed on two relative URLs", () => {
+    expect(getRelativeUrl("../url/a", "../url/a/b")).toEqual("a/b");
+    expect(getRelativeUrl("../url/a", "../url/b/c")).toEqual("b/c");
+  });
+
+  it("should fail if one seems to be relative to the domain's root, yet we don't know it", () => {
+    expect(getRelativeUrl("/url/a", "../../../url/b/c")).toEqual(null);
+    expect(getRelativeUrl("./url/a", "/url/b/c")).toEqual(null);
+    expect(getRelativeUrl("http://foo.com/url/a", "../url/b/c")).toEqual(null);
+  });
+
+  it("should succeed if both seem to be relative to the domain's root, even if we don't know it", () => {
+    expect(getRelativeUrl("/url/a", "/url/b/c")).toEqual("b/c");
+  });
+
+  const normalExamples = [
+    { input: "http://a/b/c/g", output: "g" },
+    { input: "http://a/b/c/g/", output: "g/" },
+    { input: "http://a/g", output: "../../g" },
+    { input: "http://a/b/c/d;p?y", output: "?y" },
+    { input: "http://a/b/c/g?y", output: "g?y" },
+    { input: "http://a/b/c/d;p?q#s", output: "#s" },
+    { input: "http://a/b/c/g#s", output: "g#s" },
+    { input: "http://a/b/c/g?y#s", output: "g?y#s" },
+    { input: "http://a/b/c/;x", output: ";x" },
+    { input: "http://a/b/c/g;x", output: "g;x" },
+    { input: "http://a/b/c/g;x?y#s", output: "g;x?y#s" },
+    { input: "http://a/b/c/d;p?q", output: "" },
+    { input: "http://a/b/c/", output: "." },
+    { input: "http://a/b/", output: ".." },
+    { input: "http://a/b/g", output: "../g" },
+    { input: "http://a/", output: "../.." },
+    { input: "http://a/g", output: "../../g" },
+  ];
+  normalExamples.forEach((example) => {
+    it("should conform to RFC 3986 normal examples - case: " + example.input, () => {
+      const baseURL: string = "http://a/b/c/d;p?q";
+      // https://datatracker.ietf.org/doc/html/rfc3986#section-5.4.1
+      expect(getRelativeUrl(baseURL, example.input)).toBe(example.output);
+    });
+  });
+
+  it("should succeed on two relative URLs", () => {
+    expect(getRelativeUrl("../url/a", "../url/a/b")).toEqual("a/b");
+    expect(getRelativeUrl("../url/a", "../url/b/c")).toEqual("b/c");
+  });
+
+  it("should return null if the relation between the two URLs is unclear", () => {
+    expect(getRelativeUrl("/url/a", "url/a/b")).toEqual(null);
+    expect(getRelativeUrl("url/a", "/url/a/b")).toEqual(null);
+  });
+});

package/src/utils/logger.ts

@@ -138,18 +138,17 @@ export default class Logger extends EventEmitter<ILoggerEvents> {
       /* eslint-enable no-console */
       /* eslint-enable no-invalid-this */
     } else {
-      const produceLogFn = (logLevel: ILoggerLevel, namespace: string) => {
+      const produceLogFn = (logLevel: ILoggerLevel) => {
         return level >= this._levels[logLevel]
           ? (...args: IAcceptedLogValue[]) => {
-              const now = getMonotonicTimeStamp();
-              return logFn(logLevel, [now, namespace, ...args]);
+              return logFn(logLevel, args);
             }
           : noop;
       };
-      this.error = produceLogFn("ERROR", "error");
-      this.warn = produceLogFn("WARNING", "warn");
-      this.info = produceLogFn("INFO", "info");
-      this.debug = produceLogFn("DEBUG", "log");
+      this.error = produceLogFn("ERROR");
+      this.warn = produceLogFn("WARNING");
+      this.info = produceLogFn("INFO");
+      this.debug = produceLogFn("DEBUG");
     }
 
     this.trigger("onLogLevelChange", {