const promises = {};

function loadScript(src) {
  if (promises[src]) {
    return promises[src];
  }
  let promise = (promises[src] = new Promise((resolve) => {
    var el = document.createElement("script");
    var loaded = false;
    el.onload = el.onreadystatechange = () => {
      if (
        (el.readyState &&
          el.readyState !== "complete" &&
          el.readyState !== "loaded") ||
        loaded
      ) {
        return false;
      }
      el.onload = el.onreadystatechange = null;
      loaded = true;
      resolve();
    };

    el.async = true;
    el.src = src;
    let head = document.getElementsByTagName("head")[0];
    head.insertBefore(el, head.firstChild);
  }));

  return promise;
}

/*! loadCSS: load a CSS file asynchronously. [c]2016 @scottjehl, Filament Group, Inc. Licensed MIT */
(function (w) {
  "use strict";
  /* exported loadCSS */
  var loadCSS = function (href, before, media) {
    // Arguments explained:
    // `href` [REQUIRED] is the URL for your CSS file.
    // `before` [OPTIONAL] is the element the script should use as a reference for injecting our stylesheet <link> before
    // By default, loadCSS attempts to inject the link after the last stylesheet or script in the DOM. However, you might desire a more specific location in your document.
    // `media` [OPTIONAL] is the media type or query of the stylesheet. By default it will be 'all'
    var doc = w.document;
    var ss = doc.createElement("link");
    var ref;
    if (before) {
      ref = before;
    } else {
      var refs = (doc.body || doc.getElementsByTagName("head")[0]).childNodes;
      ref = refs[refs.length - 1];
    }
    var sheets = doc.styleSheets;
    ss.rel = "stylesheet";
    ss.href = href;
    // temporarily set media to something inapplicable to ensure it'll fetch without blocking render
    ss.media = "only x";

    // wait until body is defined before injecting link. This ensures a non-blocking load in IE11.
    function ready(cb) {
      if (doc.body) {
        return cb();
      }
      setTimeout(function () {
        ready(cb);
      });
    }
    // Inject link
    // Note: the ternary preserves the existing behavior of "before" argument, but we could choose to change the argument to "after" in a later release and standardize on ref.nextSibling for all refs
    // Note: `insertBefore` is used instead of `appendChild`, for safety re: http://www.paulirish.com/2011/surefire-dom-element-insertion/
    ready(function () {
      ref.parentNode.insertBefore(ss, before ? ref : ref.nextSibling);
    });
    // A method (exposed on return object for external use) that mimics onload by polling until document.styleSheets until it includes the new sheet.
    var onloadcssdefined = function (cb) {
      var resolvedHref = ss.href;
      var i = sheets.length;
      while (i--) {
        if (sheets[i].href === resolvedHref) {
          return cb();
        }
      }
      setTimeout(function () {
        onloadcssdefined(cb);
      });
    };

    function loadCB() {
      if (ss.addEventListener) {
        ss.removeEventListener("load", loadCB);
      }
      ss.media = media || "all";
    }

    // once loaded, set link's media back to `all` so that the stylesheet applies once it loads
    if (ss.addEventListener) {
      ss.addEventListener("load", loadCB);
    }
    ss.onloadcssdefined = onloadcssdefined;
    onloadcssdefined(loadCB);
    return ss;
  };
  // commonjs
  if (typeof exports !== "undefined") {
    exports.loadCSS = loadCSS;
  } else {
    w.loadCSS = loadCSS;
  }
})(typeof global !== "undefined" ? global : this);

function loadJs(sid, jsurl, callback) {
  var nodeHead = document.getElementsByTagName("head")[0];
  var nodeScript = null;
  if (document.getElementById(sid) == null) {
    nodeScript = document.createElement("script");
    nodeScript.setAttribute("type", "text/javascript");
    nodeScript.setAttribute("src", jsurl);
    nodeScript.setAttribute("id", sid);
    if (callback != null) {
      nodeScript.onload = nodeScript.onreadystatechange = function () {
        if (nodeScript.ready) {
          return false;
        }
        if (
          !nodeScript.readyState ||
          nodeScript.readyState == "loaded" ||
          nodeScript.readyState == "complete"
        ) {
          nodeScript.ready = true;
          callback();
        }
      };
    }
    nodeHead.appendChild(nodeScript);
  } else {
    if (callback != null) {
      callback();
    }
  }
}

// load a single file
loadjs("foo.js", function () {
  // foo.js loaded
});

// load multiple files (in parallel)
loadjs(["foo.js", "bar.js"], function () {
  // foo.js & bar.js loaded
});

// load multiple files (in series)
loadjs("foo.js", function () {
  loadjs("bar.js", function () {
    // foo.js loaded then bar.js loaded
  });
});

// add a bundle id
loadjs(["foo.js", "bar.js"], "foobar", function () {
  // foo.js & bar.js loaded
});

// add a failure callback
loadjs(
  ["foo.js", "bar.js"],
  "foobar",
  function () {
    /* foo.js & bar.js loaded */
  },
  function (pathsNotFound) {
    /* at least one path didn't load */
  }
);

// execute a callback after bundle finishes loading
loadjs(["foo.js", "bar.js"], "foobar");

loadjs.ready("foobar", function () {
  // foo.js & bar.js loaded
});

// .ready() can be chained together
loadjs("foo.js", "foo");
loadjs("bar.js", "bar");

loadjs
  .ready("foo", function () {
    // foo.js loaded
  })
  .ready("bar", function () {
    // bar.js loaded
  });

// compose more complex dependency lists
loadjs("foo.js", "foo");
loadjs("bar.js", "bar");
loadjs(["thunkor.js", "thunky.js"], "thunk");

// wait for multiple depdendencies
loadjs.ready(
  ["foo", "bar", "thunk"],
  function () {
    // foo.js & bar.js & thunkor.js & thunky.js loaded
  },
  function (depsNotFound) {
    if (depsNotFound.indexOf("foo") > -1) {
    } // foo failed
    if (depsNotFound.indexOf("bar") > -1) {
    } // bar failed
    if (depsNotFound.indexOf("thunk") > -1) {
    } // thunk failed
  }
);

// use .done() for more control
loadjs.ready("my-awesome-plugin", function () {
  myAwesomePlugin();
});

loadjs.ready("jquery", function () {
  // plugin requires jquery
  window.myAwesomePlugin = function () {
    if (!window.jQuery) throw "jQuery is missing!";
  };

  // plugin is done loading
  loadjs.done("my-awesome-plugin");
});