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

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/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.2024090600";
+    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.2024090600";
+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/{resolve_url.ts → url-utils.ts}

@@ -19,9 +19,9 @@ import startsWith from "./starts_with";
 // Scheme part of an url (e.g. "http://").
 const schemeRe = /^(?:[a-z]+:)?\/\//i;
 
-/** 
+/**
  * Match the different components of an URL.
- * 
+ *
  *     foo://example.com:8042/over/there?name=ferret#nose
        \_/   \______________/\_________/ \_________/ \__/
         |           |            |            |        |
@@ -68,6 +68,85 @@ function getFilenameIndexInUrl(url: string): number {
   return indexOfLastSlash + 1;
 }
 
+/**
+ * Take two URLs and try to construct a relative URL for the second (`newUrl`)
+ * relative to the first (`baseUrl`).
+ *
+ * Returns `null` if they appear to be on different domains, depend on
+ * different schemes or if we don't have enough information to compute the
+ * relative URL.
+ * @param {string} baseUrl
+ * @param {string} newUrl
+ * @returns {string}
+ */
+function getRelativeUrl(baseUrl: string, newUrl: string): string | null {
+  const baseParts = parseURL(baseUrl);
+  const newParts = parseURL(newUrl);
+  if (
+    baseParts.scheme !== newParts.scheme ||
+    baseParts.authority !== newParts.authority
+  ) {
+    return null;
+  }
+  if (
+    // if base and new path are mixed between absolute and relative path, return null
+    (baseParts.path[0] !== undefined &&
+      baseParts.path[0] !== "/" &&
+      newParts.path[0] === "/") ||
+    (newParts.path[0] !== undefined &&
+      newParts.path[0] !== "/" &&
+      baseParts.path[0] === "/")
+  ) {
+    return null;
+  }
+
+  const baseNormalizedPath = removeDotSegment(baseParts.path);
+  const newNormalizedPath = removeDotSegment(newParts.path);
+  let relativePath: string | undefined;
+  if (baseNormalizedPath === newNormalizedPath) {
+    relativePath = "";
+  } else {
+    const basePathSplitted = baseNormalizedPath.split("/");
+    // remove everything after the last trailing /
+    basePathSplitted.pop();
+
+    const newPathSplitted = newNormalizedPath.split("/");
+
+    while (
+      basePathSplitted.length > 0 &&
+      newPathSplitted.length > 0 &&
+      basePathSplitted[0] === newPathSplitted[0]
+    ) {
+      basePathSplitted.shift();
+      newPathSplitted.shift();
+    }
+
+    while (basePathSplitted.length > 0) {
+      basePathSplitted.shift();
+      newPathSplitted.unshift("..");
+    }
+    let pathJoined = newPathSplitted.join("/");
+    if (pathJoined.endsWith("../") || pathJoined.endsWith("./")) {
+      pathJoined = pathJoined.slice(0, pathJoined.length - 1);
+    }
+    relativePath = pathJoined === "" ? "." : pathJoined;
+  }
+
+  let result = relativePath;
+  if (relativePath === "" && newParts.query === baseParts.query) {
+    // path and query is the same, we don't need to rewrite it
+  } else if (newParts.query) {
+    result += "?";
+    result += newParts.query;
+  }
+
+  if (newParts.fragment) {
+    result += "#";
+    result += newParts.fragment;
+  }
+  return result;
+}
+
 /**
  * Resolve the output URL from the baseURL and the relative reference as
  * specified by RFC 3986 section 5.
@@ -259,7 +338,7 @@ function mergePaths(baseParts: IParsedURL, relativePath: string): string {
  * @param {...(string|undefined)} args - The URL segments to resolve.
  * @returns {string} The resolved URL as a string.
  */
-export function resolveURL(...args: Array<string | undefined>): string {
+function resolveURL(...args: Array<string | undefined>): string {
   const filteredArgs = args.filter((val) => val !== "");
   const len = filteredArgs.length;
   if (len === 0) {
@@ -276,5 +355,4 @@ export function resolveURL(...args: Array<string | undefined>): string {
   }
 }
 
-export { getFilenameIndexInUrl };
-export default resolveURL;
+export { getFilenameIndexInUrl, getRelativeUrl, resolveURL };

package/dist/commonjs/utils/resolve_url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve_url.d.ts","sourceRoot":"","sources":["../../../src/utils/resolve_url.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAuBH;;;;;;;GAOG;AACH,iBAAS,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAuBlD;AAsLD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,CAerE;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC;AACjC,eAAe,UAAU,CAAC"}

package/dist/es2017/utils/resolve_url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve_url.d.ts","sourceRoot":"","sources":["../../../src/utils/resolve_url.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAuBH;;;;;;;GAOG;AACH,iBAAS,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAuBlD;AAsLD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,CAerE;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC;AACjC,eAAe,UAAU,CAAC"}