rx-player 3.26.1 → 3.26.2

package/dist/_esm5.processed/core/api/clock.js

@@ -1,363 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-/**
- * This file defines a global clock for the RxPlayer.
- *
- * Each clock tick also pass information about the current state of the
- * media element to sub-parts of the player.
- */
-import { defer as observableDefer, fromEvent as observableFromEvent, interval as observableInterval, merge as observableMerge, } from "rxjs";
-import { map, mapTo, shareReplay, startWith, } from "rxjs/operators";
-import config from "../../config";
-import log from "../../log";
-import objectAssign from "../../utils/object_assign";
-import { getRange } from "../../utils/ranges";
-var SAMPLING_INTERVAL_MEDIASOURCE = config.SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY = config.SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE = config.SAMPLING_INTERVAL_NO_MEDIASOURCE, RESUME_GAP_AFTER_SEEKING = config.RESUME_GAP_AFTER_SEEKING, RESUME_GAP_AFTER_NOT_ENOUGH_DATA = config.RESUME_GAP_AFTER_NOT_ENOUGH_DATA, RESUME_GAP_AFTER_BUFFERING = config.RESUME_GAP_AFTER_BUFFERING, REBUFFERING_GAP = config.REBUFFERING_GAP, MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING = config.MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING;
-/**
- * HTMLMediaElement Events for which timings are calculated and emitted.
- * @type {Array.<string>}
- */
-var SCANNED_MEDIA_ELEMENTS_EVENTS = ["canplay",
-    "play",
-    "seeking",
-    "seeked",
-    "loadedmetadata",
-    "ratechange"];
-/**
- * Returns the amount of time in seconds the buffer should have ahead of the
- * current position before resuming playback. Based on the infos of the
- * rebuffering status.
- *
- * Waiting time differs between a rebuffering happening after a "seek" or one
- * happening after a buffer starvation occured.
- * @param {Object|null} rebufferingStatus
- * @param {Boolean} lowLatencyMode
- * @returns {Number}
- */
-function getRebufferingEndGap(rebufferingStatus, lowLatencyMode) {
-    if (rebufferingStatus === null) {
-        return 0;
-    }
-    var suffix = lowLatencyMode ? "LOW_LATENCY" :
-        "DEFAULT";
-    switch (rebufferingStatus.reason) {
-        case "seeking":
-        case "internal-seek":
-            return RESUME_GAP_AFTER_SEEKING[suffix];
-        case "not-ready":
-            return RESUME_GAP_AFTER_NOT_ENOUGH_DATA[suffix];
-        case "buffering":
-            return RESUME_GAP_AFTER_BUFFERING[suffix];
-    }
-}
-/**
- * @param {Object} currentRange
- * @param {Number} duration
- * @param {Boolean} lowLatencyMode
- * @returns {Boolean}
- */
-function hasLoadedUntilTheEnd(currentRange, duration, lowLatencyMode) {
-    var suffix = lowLatencyMode ? "LOW_LATENCY" :
-        "DEFAULT";
-    return currentRange !== null &&
-        (duration - currentRange.end) <= REBUFFERING_GAP[suffix];
-}
-/**
- * Generate a basic timings object from the media element and the eventName
- * which triggered the request.
- * @param {HTMLMediaElement} mediaElement
- * @param {string} event
- * @returns {Object}
- */
-function getMediaInfos(mediaElement, event) {
-    var buffered = mediaElement.buffered, currentTime = mediaElement.currentTime, duration = mediaElement.duration, ended = mediaElement.ended, paused = mediaElement.paused, playbackRate = mediaElement.playbackRate, readyState = mediaElement.readyState, seeking = mediaElement.seeking;
-    var currentRange = getRange(buffered, currentTime);
-    return { bufferGap: currentRange !== null ? currentRange.end - currentTime :
-            // TODO null/0 would probably be
-            // more appropriate
-            Infinity, buffered: buffered, currentRange: currentRange, position: currentTime, duration: duration, ended: ended, paused: paused, playbackRate: playbackRate, readyState: readyState, seeking: seeking, event: event };
-}
-/**
- * Infer rebuffering status of the media based on:
- *   - the return of the function getMediaInfos
- *   - the previous timings object.
- *
- * @param {Object} prevTimings - Previous timings object. See function to know
- * the different properties needed.
- * @param {Object} currentTimings - Current timings object. This does not need
- * to have every single infos, see function to know which properties are needed.
- * @param {Object} options
- * @returns {Object|null}
- */
-function getRebufferingStatus(prevTimings, currentTimings, _a) {
-    var withMediaSource = _a.withMediaSource, lowLatencyMode = _a.lowLatencyMode;
-    var currentEvt = currentTimings.event, currentTime = currentTimings.position, bufferGap = currentTimings.bufferGap, currentRange = currentTimings.currentRange, duration = currentTimings.duration, paused = currentTimings.paused, readyState = currentTimings.readyState, ended = currentTimings.ended;
-    var prevRebuffering = prevTimings.rebuffering, prevEvt = prevTimings.event, prevTime = prevTimings.position;
-    var fullyLoaded = hasLoadedUntilTheEnd(currentRange, duration, lowLatencyMode);
-    var canSwitchToRebuffering = (readyState >= 1 &&
-        currentEvt !== "loadedmetadata" &&
-        prevRebuffering === null &&
-        !(fullyLoaded || ended));
-    var rebufferEndPosition = null;
-    var shouldRebuffer;
-    var shouldStopRebuffer;
-    var rebufferGap = lowLatencyMode ? REBUFFERING_GAP.LOW_LATENCY :
-        REBUFFERING_GAP.DEFAULT;
-    if (withMediaSource) {
-        if (canSwitchToRebuffering) {
-            if (bufferGap <= rebufferGap) {
-                shouldRebuffer = true;
-                rebufferEndPosition = currentTime + bufferGap;
-            }
-            else if (bufferGap === Infinity) {
-                shouldRebuffer = true;
-                rebufferEndPosition = currentTime;
-            }
-        }
-        else if (prevRebuffering !== null) {
-            var resumeGap = getRebufferingEndGap(prevRebuffering, lowLatencyMode);
-            if (shouldRebuffer !== true && prevRebuffering !== null && readyState > 1 &&
-                (fullyLoaded || ended || (bufferGap < Infinity && bufferGap > resumeGap))) {
-                shouldStopRebuffer = true;
-            }
-            else if (bufferGap === Infinity || bufferGap <= resumeGap) {
-                rebufferEndPosition = bufferGap === Infinity ? currentTime :
-                    currentTime + bufferGap;
-            }
-        }
-    }
-    // when using a direct file, the media will stall and unstall on its
-    // own, so we only try to detect when the media timestamp has not changed
-    // between two consecutive timeupdates
-    else {
-        if (canSwitchToRebuffering &&
-            (!paused && currentEvt === "timeupdate" &&
-                prevEvt === "timeupdate" && currentTime === prevTime ||
-                currentEvt === "seeking" && bufferGap === Infinity)) {
-            shouldRebuffer = true;
-        }
-        else if (prevRebuffering !== null &&
-            (currentEvt !== "seeking" && currentTime !== prevTime ||
-                currentEvt === "canplay" ||
-                bufferGap < Infinity &&
-                    (bufferGap > getRebufferingEndGap(prevRebuffering, lowLatencyMode) ||
-                        fullyLoaded || ended))) {
-            shouldStopRebuffer = true;
-        }
-    }
-    if (shouldStopRebuffer === true) {
-        return null;
-    }
-    else if (shouldRebuffer === true || prevRebuffering !== null) {
-        var reason = void 0;
-        if (currentEvt === "seeking" ||
-            prevRebuffering !== null && prevRebuffering.reason === "seeking") {
-            reason = "seeking";
-        }
-        else if (currentTimings.seeking &&
-            ((currentEvt === "internal-seeking") ||
-                (prevRebuffering !== null && prevRebuffering.reason === "internal-seek"))) {
-            reason = "internal-seek";
-        }
-        else if (currentTimings.seeking) {
-            reason = "seeking";
-        }
-        else if (readyState === 1) {
-            reason = "not-ready";
-        }
-        else {
-            reason = "buffering";
-        }
-        if (prevRebuffering !== null && prevRebuffering.reason === reason) {
-            return { reason: prevRebuffering.reason,
-                timestamp: prevRebuffering.timestamp,
-                position: rebufferEndPosition };
-        }
-        return { reason: reason, timestamp: performance.now(),
-            position: rebufferEndPosition };
-    }
-    return null;
-}
-/**
- * Detect if the current media can be considered as "freezing" (i.e. not
- * advancing for unknown reasons).
- *
- * Returns a corresponding `IFreezingStatus` object if that's the case and
- * `null` if not.
- * @param {Object} prevTimings
- * @param {Object} currentTimings
- * @returns {Object|null}
- */
-function getFreezingStatus(prevTimings, currentTimings) {
-    if (prevTimings.freezing) {
-        if (currentTimings.ended ||
-            currentTimings.paused ||
-            currentTimings.readyState === 0 ||
-            currentTimings.playbackRate === 0 ||
-            prevTimings.position !== currentTimings.position) {
-            return null; // Quit freezing status
-        }
-        return prevTimings.freezing; // Stay in it
-    }
-    return currentTimings.event === "timeupdate" &&
-        currentTimings.bufferGap > MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING &&
-        !currentTimings.ended &&
-        !currentTimings.paused &&
-        currentTimings.readyState >= 1 &&
-        currentTimings.playbackRate !== 0 &&
-        currentTimings.position === prevTimings.position ?
-        { timestamp: performance.now() } :
-        null;
-}
-/**
- * Timings observable.
- *
- * This Observable samples snapshots of player's current state:
- *   * time position
- *   * playback rate
- *   * current buffered range
- *   * gap with current buffered range ending
- *   * media duration
- *
- * In addition to sampling, this Observable also reacts to "seeking" and "play"
- * events.
- *
- * Observable is shared for performance reason: reduces the number of event
- * listeners and intervals/timeouts but also limit access to the media element
- * properties and gap calculations.
- *
- * The sampling is manual instead of based on "timeupdate" to reduce the
- * number of events.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} options
- * @returns {Observable}
- */
-function createClock(mediaElement, options) {
-    // Allow us to identify seek performed internally by the player.
-    var internalSeekingComingCounter = 0;
-    function setCurrentTime(time) {
-        mediaElement.currentTime = time;
-        internalSeekingComingCounter += 1;
-    }
-    var clock$ = observableDefer(function () {
-        var lastTimings = objectAssign(getMediaInfos(mediaElement, "init"), { rebuffering: null,
-            freezing: null,
-            getCurrentTime: function () { return mediaElement.currentTime; } });
-        function getCurrentClockTick(event) {
-            var tmpEvt = event;
-            if (tmpEvt === "seeking" && internalSeekingComingCounter > 0) {
-                tmpEvt = "internal-seeking";
-                internalSeekingComingCounter -= 1;
-            }
-            var mediaTimings = getMediaInfos(mediaElement, tmpEvt);
-            var rebufferingStatus = getRebufferingStatus(lastTimings, mediaTimings, options);
-            var freezingStatus = getFreezingStatus(lastTimings, mediaTimings);
-            var timings = objectAssign({}, { rebuffering: rebufferingStatus,
-                freezing: freezingStatus,
-                getCurrentTime: function () { return mediaElement.currentTime; } }, mediaTimings);
-            log.debug("API: current media element state", timings);
-            return timings;
-        }
-        var eventObs = SCANNED_MEDIA_ELEMENTS_EVENTS.map(function (eventName) {
-            return observableFromEvent(mediaElement, eventName)
-                .pipe(mapTo(eventName));
-        });
-        var interval = options.lowLatencyMode ? SAMPLING_INTERVAL_LOW_LATENCY :
-            options.withMediaSource ? SAMPLING_INTERVAL_MEDIASOURCE :
-                SAMPLING_INTERVAL_NO_MEDIASOURCE;
-        var interval$ = observableInterval(interval)
-            .pipe(mapTo("timeupdate"));
-        return observableMerge.apply(void 0, __spreadArray([interval$], eventObs, false)).pipe(map(function (event) {
-            lastTimings = getCurrentClockTick(event);
-            if (log.getLevel() === "DEBUG") {
-                log.debug("API: current playback timeline:\n" +
-                    prettyPrintBuffered(lastTimings.buffered, lastTimings.position), "\n" + event);
-            }
-            return lastTimings;
-        }), startWith(lastTimings));
-    }).pipe(
-    // Always emit the last tick when already subscribed
-    shareReplay({ bufferSize: 1, refCount: true }));
-    return { clock$: clock$, setCurrentTime: setCurrentTime };
-}
-/**
- * Pretty print a TimeRanges Object, to see the current content of it in a
- * one-liner string.
- *
- * @example
- * This function is called by giving it directly the TimeRanges, such as:
- * ```js
- * prettyPrintBuffered(document.getElementsByTagName("video")[0].buffered);
- * ```
- *
- * Let's consider this possible return:
- *
- * ```
- * 0.00|==29.95==|29.95 ~30.05~ 60.00|==29.86==|89.86
- *          ^14
- * ```
- * This means that our video element has 29.95 seconds of buffer between 0 and
- * 29.95 seconds.
- * Then 30.05 seconds where no buffer is found.
- * Then 29.86 seconds of buffer between 60.00 and 89.86 seconds.
- *
- * A caret on the second line indicates the current time we're at.
- * The number coming after it is the current time.
- * @param {TimeRanges} buffered
- * @param {number} currentTime
- * @returns {string}
- */
-function prettyPrintBuffered(buffered, currentTime) {
-    var str = "";
-    var currentTimeStr = "";
-    for (var i = 0; i < buffered.length; i++) {
-        var start = buffered.start(i);
-        var end = buffered.end(i);
-        var fixedStart = start.toFixed(2);
-        var fixedEnd = end.toFixed(2);
-        var fixedDuration = (end - start).toFixed(2);
-        var newIntervalStr = fixedStart + "|==" + fixedDuration + "==|" + fixedEnd;
-        str += newIntervalStr;
-        if (currentTimeStr.length === 0 && end > currentTime) {
-            var padBefore = str.length - Math.floor(newIntervalStr.length / 2);
-            currentTimeStr = " ".repeat(padBefore) + ("^" + currentTime);
-        }
-        if (i < buffered.length - 1) {
-            var nextStart = buffered.start(i + 1);
-            var fixedDiff = (nextStart - end).toFixed(2);
-            var holeStr = " ~" + fixedDiff + "~ ";
-            str += holeStr;
-            if (currentTimeStr.length === 0 && currentTime < nextStart) {
-                var padBefore = str.length - Math.floor(holeStr.length / 2);
-                currentTimeStr = " ".repeat(padBefore) + ("^" + currentTime);
-            }
-        }
-    }
-    if (currentTimeStr.length === 0) {
-        currentTimeStr = " ".repeat(str.length) + ("^" + currentTime);
-    }
-    return str + "\n" + currentTimeStr;
-}
-export default createClock;

package/dist/_esm5.processed/core/init/create_stream_clock.d.ts

@@ -1,34 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Observable } from "rxjs";
-import Manifest from "../../manifest";
-import { IStreamOrchestratorClockTick } from "../stream";
-import { IInitClockTick } from "./types";
-export interface IStreamClockArguments {
-    autoPlay: boolean;
-    initialPlay$: Observable<unknown>;
-    initialSeek$: Observable<unknown>;
-    manifest: Manifest;
-    speed$: Observable<number>;
-    startTime: number;
-}
-/**
- * Create clock Observable for the `Stream` part of the code.
- * @param {Observable} initClock$
- * @param {Object} streamClockArgument
- * @returns {Observable}
- */
-export default function createStreamClock(initClock$: Observable<IInitClockTick>, { autoPlay, initialPlay$, initialSeek$, manifest, speed$, startTime }: IStreamClockArguments): Observable<IStreamOrchestratorClockTick>;

package/dist/_esm5.processed/core/init/create_stream_clock.js

@@ -1,55 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { combineLatest as observableCombineLatest, merge as observableMerge, } from "rxjs";
-import { ignoreElements, map, tap, } from "rxjs/operators";
-/**
- * Create clock Observable for the `Stream` part of the code.
- * @param {Observable} initClock$
- * @param {Object} streamClockArgument
- * @returns {Observable}
- */
-export default function createStreamClock(initClock$, _a) {
-    var autoPlay = _a.autoPlay, initialPlay$ = _a.initialPlay$, initialSeek$ = _a.initialSeek$, manifest = _a.manifest, speed$ = _a.speed$, startTime = _a.startTime;
-    var initialPlayPerformed = false;
-    var initialSeekPerformed = false;
-    var updateIsPaused$ = initialPlay$.pipe(tap(function () { initialPlayPerformed = true; }), ignoreElements());
-    var updateTimeOffset$ = initialSeek$.pipe(tap(function () { initialSeekPerformed = true; }), ignoreElements());
-    var clock$ = observableCombineLatest([initClock$, speed$])
-        .pipe(map(function (_a) {
-        var tick = _a[0], speed = _a[1];
-        var isLive = manifest.isLive;
-        return {
-            position: tick.position,
-            getCurrentTime: tick.getCurrentTime,
-            duration: tick.duration,
-            isPaused: initialPlayPerformed ? tick.paused :
-                !autoPlay,
-            liveGap: isLive ? manifest.getMaximumPosition() - tick.position :
-                Infinity,
-            readyState: tick.readyState,
-            speed: speed,
-            // wantedTimeOffset is an offset to add to the timing's current time to have
-            // the "real" wanted position.
-            // For now, this is seen when the media element has not yet seeked to its
-            // initial position, the currentTime will most probably be 0 where the
-            // effective starting position will be _startTime_.
-            // Thus we initially set a wantedTimeOffset equal to startTime.
-            wantedTimeOffset: initialSeekPerformed ? 0 :
-                startTime - tick.position,
-        };
-    }));
-    return observableMerge(updateIsPaused$, updateTimeOffset$, clock$);
-}

package/dist/_esm5.processed/parsers/manifest/dash/common/extract_minimum_availability_time_offset.d.ts

@@ -1,31 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { IBaseUrlIntermediateRepresentation } from "../node_parser_types";
-/**
- * From 0 to N baseURL elements takes the minimum availabilityTimeOffset
- * possible.
- *
- * `0` if no baseURL was given (which means `no delay added`: coherent with how
- * this value is used).
- *
- * Taking the minimum time allow to simplify its processing:
- * Instead of having multiple URL each with a different pool of available
- * segment at a given instant, let's always consider every URLs by aligning with
- * the one with the most segment.
- *
- * @param {Array.<Object>} baseURLs
- */
-export default function extractMinimumAvailabilityTimeOffset(baseURLs: IBaseUrlIntermediateRepresentation[]): number;

package/dist/_esm5.processed/parsers/manifest/dash/common/extract_minimum_availability_time_offset.js

@@ -1,37 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * From 0 to N baseURL elements takes the minimum availabilityTimeOffset
- * possible.
- *
- * `0` if no baseURL was given (which means `no delay added`: coherent with how
- * this value is used).
- *
- * Taking the minimum time allow to simplify its processing:
- * Instead of having multiple URL each with a different pool of available
- * segment at a given instant, let's always consider every URLs by aligning with
- * the one with the most segment.
- *
- * @param {Array.<Object>} baseURLs
- */
-export default function extractMinimumAvailabilityTimeOffset(baseURLs) {
-    return baseURLs.length === 0 ?
-        0 :
-        baseURLs.reduce(function (acc, baseURL) {
-            var _a;
-            return Math.min((_a = baseURL.attributes.availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0, acc);
-        }, Infinity);
-}

package/scripts/doc-generator/construct_html.js

@@ -1,135 +0,0 @@
-const convertMDToHTML = require("./convert_MD_to_HMTL.js");
-
-/**
- * Construct Header part of the HTML page, containing various links.
- * @param {Object} options
- * @param {string|undefined} options.homeLink - If set, link to the homepage.
- * @param {string|undefined} options.listLink - If set, link to the page list.
- * @returns {string} - header div tag
- */
-function constructHTMLHeader({ homeLink, listLink }) {
-  let header = "<div class=\"header\"><div class=\"header-content\">";
-
-  if (homeLink != null) {
-    header += `<a href="${homeLink}">` +
-                "<span class=\"nav-icon\">🏠</span>" +
-                "<span class=\"nav-text\">Home</span>" +
-              "</a>";
-  }
-
-  if (listLink != null) {
-    header += `<a href="${listLink}">` +
-                "<span class=\"nav-icon\">🗎</span>" +
-                "<span class=\"nav-text\">Page List</span>" +
-              "</a>";
-  }
-
-  header += "<a href=\"#\">" +
-              "<span class=\"nav-icon\">↑</span>" +
-              "<span class=\"nav-text\">Top</span>" +
-            "</a>";
-
-  header += "</div></div>";
-  return header;
-}
-
-/**
- * Construct Sidebar part of the HTML page, containing various links.
- * @param {string|null|undefined} toc - Markdown for the table of contents
- * (under a list form).
- * `null` or `undefined` if your page has no table of contents.
- * @param {Object} options
- * @param {string|undefined} options.homeLink - If set, link to the homepage.
- * @param {string|undefined} options.listLink - If set, link to the page list.
- * @returns {string} - sidebar div tag
- */
-function constructHTMLSidebar(toc, {
-  homeLink,
-  listLink,
-}) {
-  const domSidebar = (toc && convertMDToHTML(toc)) || "";
-
-  let sidebar = "<div class=\"sidebar\">" +
-                "<div class=\"sidebar-nav\">";
-  if (homeLink != null) {
-    sidebar += `<a href="${homeLink}">` +
-                 "<span class=\"nav-icon\">🏠</span>" +
-                 "<span class=\"nav-text\">Home</span>" +
-               "</a>";
-  }
-
-  if (listLink != null) {
-    sidebar += `<a href="${listLink}">` +
-                 "<span class=\"nav-icon\">🗎</span>" +
-                 "<span class=\"nav-text\">Page List</span>" +
-               "</a>";
-  }
-  sidebar += "<a href=\"#\">" +
-               "<span class=\"nav-icon\">↑</span>" +
-               "<span class=\"nav-text\">Top</span>" +
-             "</a>";
-
-
-  sidebar += "</div>" +
-             "<div class=\"toc\">" +
-               domSidebar +
-             "</div>" +
-           "</div>";
-
-  return sidebar;
-}
-
-/**
- * Add links to CSS files
- * @param {Array.<string>} css - paths to CSS files
- * @returns {string}
- */
-function constructStylesHTML(css) {
-  return css.map(cssFile => `<link rel="stylesheet" href="${cssFile}"/>`)
-    .join("") || "";
-}
-
-/**
- * Generate HTML page for the given documentation.
- * /!\ do not sanitize anything. Please do it in advance.
- * @param {string} title - title of the page
- * @param {string} domContent - HTML content for the whole page.
- * @param {Object} options
- * @param {string|null|undefined} options.toc - Markdown for the table of
- * contents (under a list form).
- * `null` or `undefined` if your page has no table of contents.
- * @param {string|undefined} options.homeLink - If set, link to the homepage.
- * @param {string|undefined} options.listLink - If set, link to the page list.
- * @param {Array.<string>} css - paths to CSS files
- * @returns {string} - Whole HTML string for the documentation page.
- */
-module.exports = function constructHTMLPage(
-  title,
-  domContent,
-  { homeLink,
-    listLink,
-    toc,
-    css },
-) {
-  const header = constructHTMLHeader({ homeLink, listLink });
-  const sidebar = constructHTMLSidebar(toc, { homeLink, listLink });
-  const styles = constructStylesHTML(css);
-
-  return "<head>" +
-           "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">" +
-           "<meta charset=\"utf-8\">" +
-           styles +
-           "<title>" + title + "</title>" +
-         "</head>" +
-         "<body>" +
-           "<div class=\"page-wrapper\">" +
-             sidebar +
-             "<div class=\"content-wrapper\">" +
-               header +
-               "<div class=\"content\">" +
-                 domContent +
-               "</div>" +
-             "</div>" +
-           "</div>" +
-         "</body>";
-};