@ms-atlas/datastudio 0.1.19

package/ExternalLibraries/crossroads.min.js

@@ -0,0 +1,453 @@
+/** @license
+ * crossroads <http://millermedeiros.github.com/crossroads.js/>
+ * Author: Miller Medeiros | MIT License
+ * v0.12.0 (2013/01/21 13:47)
+ */
+(function () {
+  var a = function (a) {
+    function e(a, b) {
+      if (a.indexOf) return a.indexOf(b);
+      var c = a.length;
+      while (c--) if (a[c] === b) return c;
+      return -1;
+    }
+    function f(a, b) {
+      var c = e(a, b);
+      c !== -1 && a.splice(c, 1);
+    }
+    function g(a, b) {
+      return "[object " + b + "]" === Object.prototype.toString.call(a);
+    }
+    function h(a) {
+      return g(a, "RegExp");
+    }
+    function i(a) {
+      return g(a, "Array");
+    }
+    function j(a) {
+      return typeof a == "function";
+    }
+    function k(a) {
+      var b;
+      return (
+        a === null || a === "null"
+          ? (b = null)
+          : a === "true"
+          ? (b = !0)
+          : a === "false"
+          ? (b = !1)
+          : a === d || a === "undefined"
+          ? (b = d)
+          : a === "" || isNaN(a)
+          ? (b = a)
+          : (b = parseFloat(a)),
+        b
+      );
+    }
+    function l(a) {
+      var b = a.length,
+        c = [];
+      while (b--) c[b] = k(a[b]);
+      return c;
+    }
+    function m(a, b) {
+      var c = (a || "").replace("?", "").split("&"),
+        d = c.length,
+        e = {},
+        f,
+        g;
+      while (d--)
+        (f = c[d].split("=")),
+          (g = b ? k(f[1]) : f[1]),
+          (e[f[0]] = typeof g == "string" ? decodeURIComponent(g) : g);
+      return e;
+    }
+    function n() {
+      (this.bypassed = new a.Signal()),
+        (this.routed = new a.Signal()),
+        (this._routes = []),
+        (this._prevRoutes = []),
+        (this._piped = []),
+        this.resetState();
+    }
+    function o(b, c, d, e) {
+      var f = h(b),
+        g = e.patternLexer;
+      (this._router = e),
+        (this._pattern = b),
+        (this._paramsIds = f ? null : g.getParamIds(b)),
+        (this._optionalParamsIds = f ? null : g.getOptionalParamsIds(b)),
+        (this._matchRegexp = f ? b : g.compilePattern(b, e.ignoreCase)),
+        (this.matched = new a.Signal()),
+        (this.switched = new a.Signal()),
+        c && this.matched.add(c),
+        (this._priority = d || 0);
+    }
+    var b, c, d;
+    return (
+      (c = /t(.+)?/.exec("t")[1] === ""),
+      (n.prototype = {
+        greedy: !1,
+        greedyEnabled: !0,
+        ignoreCase: !0,
+        ignoreState: !1,
+        shouldTypecast: !1,
+        normalizeFn: null,
+        resetState: function () {
+          (this._prevRoutes.length = 0),
+            (this._prevMatchedRequest = null),
+            (this._prevBypassedRequest = null);
+        },
+        create: function () {
+          return new n();
+        },
+        addRoute: function (a, b, c) {
+          var d = new o(a, b, c, this);
+          return this._sortedInsert(d), d;
+        },
+        removeRoute: function (a) {
+          f(this._routes, a), a._destroy();
+        },
+        removeAllRoutes: function () {
+          var a = this.getNumRoutes();
+          while (a--) this._routes[a]._destroy();
+          this._routes.length = 0;
+        },
+        parse: function (a, b) {
+          (a = a || ""), (b = b || []);
+          if (
+            !this.ignoreState &&
+            (a === this._prevMatchedRequest || a === this._prevBypassedRequest)
+          )
+            return;
+          var c = this._getMatchedRoutes(a),
+            d = 0,
+            e = c.length,
+            f;
+          if (e) {
+            (this._prevMatchedRequest = a),
+              this._notifyPrevRoutes(c, a),
+              (this._prevRoutes = c);
+            while (d < e)
+              (f = c[d]),
+                f.route.matched.dispatch.apply(
+                  f.route.matched,
+                  b.concat(f.params)
+                ),
+                (f.isFirst = !d),
+                this.routed.dispatch.apply(this.routed, b.concat([a, f])),
+                (d += 1);
+          } else
+            (this._prevBypassedRequest = a),
+              this.bypassed.dispatch.apply(this.bypassed, b.concat([a]));
+          this._pipeParse(a, b);
+        },
+        _notifyPrevRoutes: function (a, b) {
+          var c = 0,
+            d;
+          while ((d = this._prevRoutes[c++]))
+            d.route.switched &&
+              this._didSwitch(d.route, a) &&
+              d.route.switched.dispatch(b);
+        },
+        _didSwitch: function (a, b) {
+          var c,
+            d = 0;
+          while ((c = b[d++])) if (c.route === a) return !1;
+          return !0;
+        },
+        _pipeParse: function (a, b) {
+          var c = 0,
+            d;
+          while ((d = this._piped[c++])) d.parse(a, b);
+        },
+        getNumRoutes: function () {
+          return this._routes.length;
+        },
+        _sortedInsert: function (a) {
+          var b = this._routes,
+            c = b.length;
+          do --c;
+          while (b[c] && a._priority <= b[c]._priority);
+          b.splice(c + 1, 0, a);
+        },
+        _getMatchedRoutes: function (a) {
+          var b = [],
+            c = this._routes,
+            d = c.length,
+            e;
+          while ((e = c[--d])) {
+            (!b.length || this.greedy || e.greedy) &&
+              e.match(a) &&
+              b.push({ route: e, params: e._getParamsArray(a) });
+            if (!this.greedyEnabled && b.length) break;
+          }
+          return b;
+        },
+        pipe: function (a) {
+          this._piped.push(a);
+        },
+        unpipe: function (a) {
+          f(this._piped, a);
+        },
+        toString: function () {
+          return "[crossroads numRoutes:" + this.getNumRoutes() + "]";
+        },
+      }),
+      (b = new n()),
+      (b.VERSION = "0.12.0"),
+      (b.NORM_AS_ARRAY = function (a, b) {
+        return [b.vals_];
+      }),
+      (b.NORM_AS_OBJECT = function (a, b) {
+        return [b];
+      }),
+      (o.prototype = {
+        greedy: !1,
+        rules: void 0,
+        match: function (a) {
+          return (
+            (a = a || ""), this._matchRegexp.test(a) && this._validateParams(a)
+          );
+        },
+        _validateParams: function (a) {
+          var b = this.rules,
+            c = this._getParamsObject(a),
+            d;
+          for (d in b)
+            if (
+              d !== "normalize_" &&
+              b.hasOwnProperty(d) &&
+              !this._isValidParam(a, d, c)
+            )
+              return !1;
+          return !0;
+        },
+        _isValidParam: function (a, b, c) {
+          var d = this.rules[b],
+            f = c[b],
+            g = !1,
+            k = b.indexOf("?") === 0;
+          return (
+            f == null &&
+            this._optionalParamsIds &&
+            e(this._optionalParamsIds, b) !== -1
+              ? (g = !0)
+              : h(d)
+              ? (k && (f = c[b + "_"]), (g = d.test(f)))
+              : i(d)
+              ? (k && (f = c[b + "_"]), (g = this._isValidArrayRule(d, f)))
+              : j(d) && (g = d(f, a, c)),
+            g
+          );
+        },
+        _isValidArrayRule: function (a, b) {
+          if (!this._router.ignoreCase) return e(a, b) !== -1;
+          typeof b == "string" && (b = b.toLowerCase());
+          var c = a.length,
+            d,
+            f;
+          while (c--) {
+            (d = a[c]), (f = typeof d == "string" ? d.toLowerCase() : d);
+            if (f === b) return !0;
+          }
+          return !1;
+        },
+        _getParamsObject: function (a) {
+          var b = this._router.shouldTypecast,
+            d = this._router.patternLexer.getParamValues(
+              a,
+              this._matchRegexp,
+              b
+            ),
+            f = {},
+            g = d.length,
+            h,
+            i;
+          while (g--)
+            (i = d[g]),
+              this._paramsIds &&
+                ((h = this._paramsIds[g]),
+                h.indexOf("?") === 0 &&
+                  i &&
+                  ((f[h + "_"] = i), (i = m(i, b)), (d[g] = i)),
+                c &&
+                  i === "" &&
+                  e(this._optionalParamsIds, h) !== -1 &&
+                  ((i = void 0), (d[g] = i)),
+                (f[h] = i)),
+              (f[g] = i);
+          return (f.request_ = b ? k(a) : a), (f.vals_ = d), f;
+        },
+        _getParamsArray: function (a) {
+          var b = this.rules ? this.rules.normalize_ : null,
+            c;
+          return (
+            (b = b || this._router.normalizeFn),
+            b && j(b)
+              ? (c = b(a, this._getParamsObject(a)))
+              : (c = this._getParamsObject(a).vals_),
+            c
+          );
+        },
+        interpolate: function (a) {
+          var b = this._router.patternLexer.interpolate(this._pattern, a);
+          if (!this._validateParams(b))
+            throw new Error(
+              "Generated string doesn't validate against `Route.rules`."
+            );
+          return b;
+        },
+        dispose: function () {
+          this._router.removeRoute(this);
+        },
+        _destroy: function () {
+          this.matched.dispose(),
+            this.switched.dispose(),
+            (this.matched =
+              this.switched =
+              this._pattern =
+              this._matchRegexp =
+                null);
+        },
+        toString: function () {
+          return (
+            '[Route pattern:"' +
+            this._pattern +
+            '", numListeners:' +
+            this.matched.getNumListeners() +
+            "]"
+          );
+        },
+      }),
+      (n.prototype.patternLexer = (function () {
+        function j() {
+          var a, b;
+          for (a in e)
+            e.hasOwnProperty(a) &&
+              ((b = e[a]),
+              (b.id = "__CR_" + a + "__"),
+              (b.save = "save" in b ? b.save.replace("{{id}}", b.id) : b.id),
+              (b.rRestore = new RegExp(b.id, "g")));
+        }
+        function k(a, b) {
+          var c = [],
+            d;
+          a.lastIndex = 0;
+          while ((d = a.exec(b))) c.push(d[1]);
+          return c;
+        }
+        function m(a) {
+          return k(d, a);
+        }
+        function n(a) {
+          return k(e.OP.rgx, a);
+        }
+        function o(d, e) {
+          return (
+            (d = d || ""),
+            d &&
+              (i === f
+                ? (d = d.replace(b, ""))
+                : i === h && (d = d.replace(c, "")),
+              (d = p(d, "rgx", "save")),
+              (d = d.replace(a, "\\$&")),
+              (d = p(d, "rRestore", "res")),
+              i === f && (d = "\\/?" + d)),
+            i !== g && (d += "\\/?"),
+            new RegExp("^" + d + "$", e ? "i" : "")
+          );
+        }
+        function p(a, b, c) {
+          var d, f;
+          for (f in e)
+            e.hasOwnProperty(f) && ((d = e[f]), (a = a.replace(d[b], d[c])));
+          return a;
+        }
+        function q(a, b, c) {
+          var d = b.exec(a);
+          return d && (d.shift(), c && (d = l(d))), d;
+        }
+        function r(a, b) {
+          if (typeof a != "string")
+            throw new Error("Route pattern should be a string.");
+          var c = function (a, c) {
+            var d;
+            c = c.substr(0, 1) === "?" ? c.substr(1) : c;
+            if (b[c] != null) {
+              if (typeof b[c] == "object") {
+                var e = [];
+                for (var f in b[c]) e.push(encodeURI(f + "=" + b[c][f]));
+                d = "?" + e.join("&");
+              } else d = String(b[c]);
+              if (a.indexOf("*") === -1 && d.indexOf("/") !== -1)
+                throw new Error(
+                  'Invalid value "' + d + '" for segment "' + a + '".'
+                );
+            } else {
+              if (a.indexOf("{") !== -1)
+                throw new Error("The segment " + a + " is required.");
+              d = "";
+            }
+            return d;
+          };
+          return (
+            e.OS.trail || (e.OS.trail = new RegExp("(?:" + e.OS.id + ")+$")),
+            a
+              .replace(e.OS.rgx, e.OS.save)
+              .replace(d, c)
+              .replace(e.OS.trail, "")
+              .replace(e.OS.rRestore, "/")
+          );
+        }
+        var a = /[\\.+*?\^$\[\](){}\/'#]/g,
+          b = /^\/|\/$/g,
+          c = /\/$/g,
+          d = /(?:\{|:)([^}:]+)(?:\}|:)/g,
+          e = {
+            OS: {
+              rgx: /([:}]|\w(?=\/))\/?(:|(?:\{\?))/g,
+              save: "$1{{id}}$2",
+              res: "\\/?",
+            },
+            RS: { rgx: /([:}])\/?(\{)/g, save: "$1{{id}}$2", res: "\\/" },
+            RQ: { rgx: /\{\?([^}]+)\}/g, res: "\\?([^#]+)" },
+            OQ: { rgx: /:\?([^:]+):/g, res: "(?:\\?([^#]*))?" },
+            OR: { rgx: /:([^:]+)\*:/g, res: "(.*)?" },
+            RR: { rgx: /\{([^}]+)\*\}/g, res: "(.+)" },
+            RP: { rgx: /\{([^}]+)\}/g, res: "([^\\/?]+)" },
+            OP: { rgx: /:([^:]+):/g, res: "([^\\/?]+)?/?" },
+          },
+          f = 1,
+          g = 2,
+          h = 3,
+          i = f;
+        return (
+          j(),
+          {
+            strict: function () {
+              i = g;
+            },
+            loose: function () {
+              i = f;
+            },
+            legacy: function () {
+              i = h;
+            },
+            getParamIds: m,
+            getOptionalParamsIds: n,
+            getParamValues: q,
+            compilePattern: o,
+            interpolate: r,
+          }
+        );
+      })()),
+      b
+    );
+  };
+  typeof define == "function" && define.amd
+    ? define(["signals"], a)
+    : typeof module != "undefined" && module.exports
+    ? (module.exports = a(require("signals")))
+    : (window.crossroads = a(window.signals));
+})();

package/ExternalLibraries/css.js

@@ -0,0 +1,165 @@
+/*
+ * Require-CSS RequireJS css! loader plugin
+ * 0.1.8
+ * Guy Bedford 2014
+ * MIT
+ */
+
+/*
+ *
+ * Usage:
+ *  require(['css!./mycssFile']);
+ *
+ * Tested and working in (up to latest versions as of March 2013):
+ * Android
+ * iOS 6
+ * IE 6 - 10
+ * Chome 3 - 26
+ * Firefox 3.5 - 19
+ * Opera 10 - 12
+ *
+ * browserling.com used for virtual testing environment
+ *
+ * Credit to B Cavalier & J Hann for the IE 6 - 9 method,
+ * refined with help from Martin Cermak
+ *
+ * Sources that helped along the way:
+ * - https://developer.mozilla.org/en-US/docs/Browser_detection_using_the_user_agent
+ * - http://www.phpied.com/when-is-a-stylesheet-really-loaded/
+ * - https://github.com/cujojs/curl/blob/master/src/curl/plugin/css.js
+ *
+ */
+
+define([], function () {
+  if (typeof window == "undefined")
+    return {
+      load: function (n, r, load) {
+        load();
+      },
+    };
+
+  var head = document.getElementsByTagName("head")[0];
+
+  var engine =
+    window.navigator.userAgent.match(
+      /Trident\/([^ ;]*)|AppleWebKit\/([^ ;]*)|Opera\/([^ ;]*)|rv\:([^ ;]*)(.*?)Gecko\/([^ ;]*)|MSIE\s([^ ;]*)|AndroidWebKit\/([^ ;]*)/
+    ) || 0;
+
+  // use <style> @import load method (IE < 9, Firefox < 18)
+  var useImportLoad = false;
+
+  // set to false for explicit <link> load checking when onload doesn't work perfectly (webkit)
+  var useOnload = true;
+
+  // trident / msie
+  if (engine[1] || engine[7])
+    useImportLoad = parseInt(engine[1]) < 6 || parseInt(engine[7]) <= 9;
+  // webkit
+  else if (engine[2] || engine[8]) useOnload = false;
+  // gecko
+  else if (engine[4]) useImportLoad = parseInt(engine[4]) < 18;
+
+  //main api object
+  var cssAPI = {};
+
+  cssAPI.pluginBuilder = "./css-builder";
+
+  // <style> @import load method
+  var curStyle, curSheet;
+  var createStyle = function () {
+    curStyle = document.createElement("style");
+    head.appendChild(curStyle);
+    curSheet = curStyle.styleSheet || curStyle.sheet;
+  };
+  var ieCnt = 0;
+  var ieLoads = [];
+  var ieCurCallback;
+
+  var createIeLoad = function (url) {
+    curSheet.addImport(url);
+    curStyle.onload = function () {
+      processIeLoad();
+    };
+
+    ieCnt++;
+    if (ieCnt == 31) {
+      createStyle();
+      ieCnt = 0;
+    }
+  };
+  var processIeLoad = function () {
+    ieCurCallback();
+
+    var nextLoad = ieLoads.shift();
+
+    if (!nextLoad) {
+      ieCurCallback = null;
+      return;
+    }
+
+    ieCurCallback = nextLoad[1];
+    createIeLoad(nextLoad[0]);
+  };
+  var importLoad = function (url, callback) {
+    if (!curSheet || !curSheet.addImport) createStyle();
+
+    if (curSheet && curSheet.addImport) {
+      // old IE
+      if (ieCurCallback) {
+        ieLoads.push([url, callback]);
+      } else {
+        createIeLoad(url);
+        ieCurCallback = callback;
+      }
+    } else {
+      // old Firefox
+      curStyle.textContent = '@import "' + url + '";';
+
+      var loadInterval = setInterval(function () {
+        try {
+          curStyle.sheet.cssRules;
+          clearInterval(loadInterval);
+          callback();
+        } catch (e) {}
+      }, 10);
+    }
+  };
+
+  // <link> load method
+  var linkLoad = function (url, callback) {
+    var link = document.createElement("link");
+    link.type = "text/css";
+    link.rel = "stylesheet";
+    if (useOnload)
+      link.onload = function () {
+        link.onload = function () {};
+        // for style dimensions queries, a short delay can still be necessary
+        setTimeout(callback, 7);
+      };
+    else
+      var loadInterval = setInterval(function () {
+        for (var i = 0; i < document.styleSheets.length; i++) {
+          var sheet = document.styleSheets[i];
+          if (sheet.href == link.href) {
+            clearInterval(loadInterval);
+            return callback();
+          }
+        }
+      }, 10);
+    link.href = url;
+    head.appendChild(link);
+  };
+
+  cssAPI.normalize = function (name, normalize) {
+    if (name.substr(name.length - 4, 4) == ".css")
+      name = name.substr(0, name.length - 4);
+
+    return normalize(name);
+  };
+
+  cssAPI.load = function (cssId, req, load, config) {
+    (useImportLoad ? importLoad : linkLoad)(req.toUrl(cssId + ".css"), load);
+  };
+
+  return cssAPI;
+});