Add js source needed for minimal embed scripts

www/js/embed-src/analytics.js

+/* global define: false */
+define(['jquery'], function($) {
+	"use strict";
+	var wdnProp = 'UA-3203435-1';
+	var unlDomain = '.unl.edu';
+	var Plugin;
+	var thisURL = String(window.location);
+
+	var gaWdnName = 'wdn';
+	var gaWdn = gaWdnName + '.';
+
+	// ga.js method for getting default tracker (with set account)
+	var getDefaultGATracker = function() {
+		var tracker = _gat._getTrackerByName();
+		if (tracker._getAccount() !== 'UA-XXXXX-X') {
+			return tracker;
+		}
+
+		return undefined;
+	};
+
+	// analytics.js method for getting default tracker
+	var getDefaultAnalyticsTracker = function() {
+		return ga.getByName('t0');
+	};
+
+	Plugin = {
+		initialize : function() {
+			ga('create', wdnProp, {
+				name: gaWdnName,
+				cookieDomain: unlDomain,
+				allowLinker: true
+			});
+		},
+
+		callTrackPageview: function(thePage, trackInWDNAccount){
+			var action = 'pageview', method = 'send', legacyMethod = '_trackPageview';
+
+			if (!thePage) {
+				ga(gaWdn+method, action);
+				return;
+			}
+
+			if (trackInWDNAccount !== false) {
+				trackInWDNAccount = true;
+			}
+
+			// First, track in the wdn analytics
+			if (trackInWDNAccount) {
+				ga(gaWdn+method, action, thePage);
+			}
+
+			// Second, track in local site analytics
+			try {
+				_gaq.push(function() {
+					var tracker = getDefaultGATracker();
+					if (tracker) {
+						tracker[legacyMethod](thePage);
+					}
+				});
+
+				ga(function() {
+					var tracker = getDefaultAnalyticsTracker();
+					if (tracker) {
+						tracker[method](action, thePage);
+					}
+				});
+			} catch(e) {}
+		},
+
+		callTrackEvent: function(category, evtaction, label, value, noninteraction) {
+			var action = 'event', method = 'send', legacyMethod = '_trackEvent', evtOpt;
+
+			if (noninteraction !== true) {
+				noninteraction = false;
+			}
+
+			evtOpt = {
+				eventCategory: category,
+				eventAction: evtaction,
+				eventLabel: label,
+				eventValue: value,
+				nonInteraction: noninteraction
+			};
+
+			ga(gaWdn+method, action, evtOpt);
+
+			try {
+				_gaq.push(function() {
+					var tracker = getDefaultGATracker(), legacyValue = value;
+					if (tracker) {
+						if (typeof value !== "undefined") {
+							legacyValue = Math.floor(value);
+						}
+
+						tracker[legacyMethod](category, evtaction, label, legacyValue, noninteraction);
+					}
+				});
+
+				ga(function() {
+					var tracker = getDefaultAnalyticsTracker();
+					if (tracker) {
+						tracker[method](action, evtOpt);
+					}
+				});
+			} catch(e) {}
+		},
+
+		callTrackTiming: function(category, variable, value, label, sampleRate) {
+			var action = 'timing', method = 'send', legacyMethod = '_trackTiming';
+
+			ga(gaWdn+method, action, category, variable, value, label);
+
+			try {
+				_gaq.push(function() {
+					var tracker = getDefaultGATracker();
+					if (tracker) {
+						tracker[legacyMethod](category, variable, value, label, sampleRate);
+					}
+				});
+
+				ga(function() {
+					var tracker = getDefaultAnalyticsTracker();
+					if (tracker) {
+						tracker[method](action, category, variable, value, label);
+					}
+				});
+
+			} catch (e) {}
+		}
+	};
+
+	return Plugin;
+});

www/js/embed-src/main.js

+requirejs.config({
+	map: {
+		"*": {
+			css: 'require-css/css'
+		}
+	}
+});

www/js/embed-src/require-css/LICENSE

+MIT License
+-----------
+
+Copyright (C) 2013 Guy Bedford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

www/js/embed-src/require-css/css-builder.js

+define(['require', './normalize'], function(req, normalize) {
+  var cssAPI = {};
+
+  var isWindows = !!process.platform.match(/^win/);
+
+  function compress(css) {
+    if (config.optimizeCss == 'none') {
+      return css;
+    }
+
+    if (typeof process !== "undefined" && process.versions && !!process.versions.node && require.nodeRequire) {
+      var csso;
+      try {
+        csso = require.nodeRequire('csso');
+      }
+      catch(e) {
+        console.log('Compression module not installed. Use "npm install csso -g" to enable.');
+        return css;
+      }
+      var csslen = css.length;
+      try {
+        css =  (csso.minify || csso.justDoIt)(css);
+      }
+      catch(e) {
+        console.log('Compression failed due to a CSS syntax error.');
+        return css;
+      }
+      console.log('Compressed CSS output to ' + Math.round(css.length / csslen * 100) + '%.');
+      return css;
+    }
+    console.log('Compression not supported outside of nodejs environments.');
+    return css;
+  }
+
+  //load file code - stolen from text plugin
+  function loadFile(path) {
+    var file;
+    if (typeof process !== "undefined" && process.versions && !!process.versions.node && require.nodeRequire) {
+      var fs = require.nodeRequire('fs');
+      file = fs.readFileSync(path, 'utf8');
+      if (file.indexOf('\uFEFF') === 0)
+        return file.substring(1);
+      return file;
+    }
+    else {
+      file = new java.io.File(path);
+      var lineSeparator = java.lang.System.getProperty("line.separator"),
+        input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(file), 'utf-8')),
+        stringBuffer, line;
+      try {
+        stringBuffer = new java.lang.StringBuffer();
+        line = input.readLine();
+        if (line && line.length() && line.charAt(0) === 0xfeff)
+          line = line.substring(1);
+        stringBuffer.append(line);
+        while ((line = input.readLine()) !== null) {
+          stringBuffer.append(lineSeparator).append(line);
+        }
+        return String(stringBuffer.toString());
+      }
+      finally {
+        input.close();
+      }
+    }
+  }
+
+
+  function saveFile(path, data) {
+    if (typeof process !== "undefined" && process.versions && !!process.versions.node && require.nodeRequire) {
+      var fs = require.nodeRequire('fs');
+      fs.writeFileSync(path, data, 'utf8');
+    }
+    else {
+      var content = new java.lang.String(data);
+      var output = new java.io.BufferedWriter(new java.io.OutputStreamWriter(new java.io.FileOutputStream(path), 'utf-8'));
+
+      try {
+        output.write(content, 0, content.length());
+        output.flush();
+      }
+      finally {
+        output.close();
+      }
+    }
+  }
+
+  //when adding to the link buffer, paths are normalised to the baseUrl
+  //when removing from the link buffer, paths are normalised to the output file path
+  function escape(content) {
+    return content.replace(/(["'\\])/g, '\\$1')
+      .replace(/[\f]/g, "\\f")
+      .replace(/[\b]/g, "\\b")
+      .replace(/[\n]/g, "\\n")
+      .replace(/[\t]/g, "\\t")
+      .replace(/[\r]/g, "\\r");
+  }
+
+  // NB add @media query support for media imports
+  var importRegEx = /@import\s*(url)?\s*(('([^']*)'|"([^"]*)")|\(('([^']*)'|"([^"]*)"|([^\)]*))\))\s*;?/g;
+  var absUrlRegEx = /^([^\:\/]+:\/)?\//;
+
+  // Write Css module definition
+  var writeCSSDefinition = "define('@writecss', function() {return function writeCss(c) {var d=document,a='appendChild',i='styleSheet',s=d.createElement('style');s.type='text/css';d.getElementsByTagName('head')[0][a](s);s[i]?s[i].cssText=c:s[a](d.createTextNode(c));};});";
+
+  var siteRoot;
+
+  var baseParts = req.toUrl('base_url').split('/');
+  baseParts[baseParts.length - 1] = '';
+  var baseUrl = baseParts.join('/');
+
+  var curModule = 0;
+  var config;
+
+  var writeCSSForLayer = true;
+  var layerBuffer = [];
+  var cssBuffer = {};
+
+  cssAPI.load = function(name, req, load, _config) {
+    //store config
+    config = config || _config;
+
+    if (!siteRoot) {
+      siteRoot = (path.resolve(config.dir || path.dirname(config.out), config.siteRoot || '.') + '/').substr(1);
+      if (isWindows)
+        siteRoot = siteRoot.replace(/\\/g, '/');
+    }
+
+    //external URLS don't get added (just like JS requires)
+    if (name.match(absUrlRegEx))
+      return load();
+
+    var fileUrl = req.toUrl(name + '.css');
+    if (isWindows)
+      fileUrl = fileUrl.replace(/\\/g, '/');
+
+    // rebase to the output directory if based on the source directory;
+    // baseUrl points always to the output directory, fileUrl only if
+    // it is not prefixed by a computed path (relative too)
+    var fileSiteUrl = fileUrl;
+    if (fileSiteUrl.indexOf(baseUrl) < 0) {
+      var appRoot = req.toUrl(config.appDir);
+      if (isWindows)
+        appRoot = appRoot.replace(/\\/g, '/');
+      if (fileSiteUrl.indexOf(appRoot) === 0)
+        fileSiteUrl = siteRoot + fileSiteUrl.substring(appRoot.length);
+    } else if (config.deployRoot) {
+      siteRoot = '/';
+      fileSiteUrl = config.deployRoot + fileSiteUrl.substring(baseUrl.length);
+    } else {
+      fileSiteUrl = fileSiteUrl.substr(1);
+    }
+
+    //add to the buffer
+    cssBuffer[name] = normalize(loadFile(fileUrl), fileSiteUrl, siteRoot);
+
+    load();
+  };
+
+  cssAPI.normalize = function(name, normalize) {
+    if (name.substr(name.length - 4, 4) == '.css')
+      name = name.substr(0, name.length - 4);
+    return normalize(name);
+  };
+
+  cssAPI.write = function(pluginName, moduleName, write, parse) {
+    var cssModule;
+
+    //external URLS don't get added (just like JS requires)
+    if (moduleName.match(absUrlRegEx))
+      return;
+
+    layerBuffer.push(cssBuffer[moduleName]);
+
+    if (!global._requirejsCssData) {
+      global._requirejsCssData = {
+        usedBy: {css: true},
+        css: ''
+      };
+    } else {
+      global._requirejsCssData.usedBy.css = true;
+    }
+
+    if (config.buildCSS !== false) {
+      var style = cssBuffer[moduleName];
+
+      if (config.writeCSSModule && style) {
+ 	    if (writeCSSForLayer) {
+    	  writeCSSForLayer = false;
+          write(writeCSSDefinition);
+        }
+
+        cssModule = 'define(["@writecss"], function(writeCss){\n writeCss("'+ escape(compress(style)) +'");\n})';
+      }
+      else {
+		cssModule = 'define(function(){})';
+      }
+
+      write.asModule(pluginName + '!' + moduleName, cssModule);
+    }
+  };
+
+  cssAPI.onLayerEnd = function(write, data) {
+    if (config.separateCSS && config.IESelectorLimit)
+      throw 'RequireCSS: separateCSS option is not compatible with ensuring the IE selector limit';
+
+    if (config.separateCSS) {
+      var outPath = data.path.replace(/(\.js)?$/, '.css');
+      console.log('Writing CSS! file: ' + outPath + '\n');
+
+      var css = layerBuffer.join('');
+
+      process.nextTick(function() {
+        if (global._requirejsCssData) {
+          css = global._requirejsCssData.css = css + global._requirejsCssData.css;
+          delete global._requirejsCssData.usedBy.css;
+          if (Object.keys(global._requirejsCssData.usedBy).length === 0) {
+            delete global._requirejsCssData;
+          }
+        }
+
+        saveFile(outPath, compress(css));
+      });
+
+    }
+    else if (config.buildCSS !== false && config.writeCSSModule !== true) {
+      var styles = config.IESelectorLimit ? layerBuffer : [layerBuffer.join('')];
+      for (var i = 0; i < styles.length; i++) {
+        if (styles[i] === '')
+          return;
+        write(
+          "(function(c){var d=document,a='appendChild',i='styleSheet',s=d.createElement('style');s.type='text/css';d.getElementsByTagName('head')[0][a](s);s[i]?s[i].cssText=c:s[a](d.createTextNode(c));})\n" +
+          "('" + escape(compress(styles[i])) + "');\n"
+        );
+      }
+    }
+    //clear layer buffer for next layer
+    layerBuffer = [];
+    writeCSSForLayer = true;
+  };
+
+  return cssAPI;
+});

www/js/embed-src/require-css/css.js

+/*
+ * 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() {
+//>>excludeStart('excludeRequireCss', pragmas.excludeRequireCss)
+  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;
+
+//>>excludeEnd('excludeRequireCss')
+  //main api object
+  var cssAPI = {};
+
+//>>excludeStart('excludeRequireCss', pragmas.excludeRequireCss)
+  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);
+  }
+
+//>>excludeEnd('excludeRequireCss')
+  cssAPI.normalize = function(name, normalize) {
+    if (name.substr(name.length - 4, 4) == '.css')
+      name = name.substr(0, name.length - 4);
+
+    return normalize(name);
+  }
+
+//>>excludeStart('excludeRequireCss', pragmas.excludeRequireCss)
+  cssAPI.load = function(cssId, req, load, config) {
+
+    (useImportLoad ? importLoad : linkLoad)(req.toUrl(cssId + '.css'), load);
+
+  }
+
+//>>excludeEnd('excludeRequireCss')
+  return cssAPI;
+});

www/js/embed-src/require-css/normalize.js

+//>>excludeStart('excludeRequireCss', pragmas.excludeRequireCss)
+/*
+ * css.normalize.js
+ *
+ * CSS Normalization
+ *
+ * CSS paths are normalized based on an optional basePath and the RequireJS config
+ *
+ * Usage:
+ *   normalize(css, fromBasePath, toBasePath);
+ *
+ * css: the stylesheet content to normalize
+ * fromBasePath: the absolute base path of the css relative to any root (but without ../ backtracking)
+ * toBasePath: the absolute new base path of the css relative to the same root
+ * 
+ * Absolute dependencies are left untouched.
+ *
+ * Urls in the CSS are picked up by regular expressions.
+ * These will catch all statements of the form:
+ *
+ * url(*)
+ * url('*')
+ * url("*")
+ * 
+ * @import '*'
+ * @import "*"
+ *
+ * (and so also @import url(*) variations)
+ *
+ * For urls needing normalization
+ *
+ */
+
+define(function() {
+  
+  // regular expression for removing double slashes
+  // eg http://www.example.com//my///url/here -> http://www.example.com/my/url/here
+  var slashes = /([^:])\/+/g
+  var removeDoubleSlashes = function(uri) {
+    return uri.replace(slashes, '$1/');
+  }
+
+  // given a relative URI, and two absolute base URIs, convert it from one base to another
+  var protocolRegEx = /([^\:\/]*):\/\/([^\/]*)/;
+  var absUrlRegEx = /^(\/|data:)/;
+  function convertURIBase(uri, fromBase, toBase) {
+    if (uri.match(absUrlRegEx) || uri.match(protocolRegEx))
+      return uri;
+    uri = removeDoubleSlashes(uri);
+    // if toBase specifies a protocol path, ensure this is the same protocol as fromBase, if not
+    // use absolute path at fromBase
+    var toBaseProtocol = toBase.match(protocolRegEx);
+    var fromBaseProtocol = fromBase.match(protocolRegEx);
+    if (fromBaseProtocol && (!toBaseProtocol || toBaseProtocol[1] != fromBaseProtocol[1] || toBaseProtocol[2] != fromBaseProtocol[2]))
+      return absoluteURI(uri, fromBase);
+    else if (toBase.match(absUrlRegEx))
+      return absoluteURI(absoluteURI(uri, fromBase), toBase); 
+    else {
+      return relativeURI(absoluteURI(uri, fromBase), toBase);
+    }
+  };
+  
+  // given a relative URI, calculate the absolute URI
+  function absoluteURI(uri, base) {
+    if (uri.substr(0, 2) == './')
+      uri = uri.substr(2);
+
+    // absolute urls are left in tact
+    if (uri.match(absUrlRegEx) || uri.match(protocolRegEx))
+      return uri;
+    
+    var baseParts = base.split('/');
+    var uriParts = uri.split('/');
+    
+    baseParts.pop();
+    
+    while (curPart = uriParts.shift())
+      if (curPart == '..')
+        baseParts.pop();
+      else
+        baseParts.push(curPart);
+    
+    return baseParts.join('/');
+  };
+
+
+  // given an absolute URI, calculate the relative URI
+  function relativeURI(uri, base) {
+    
+    // reduce base and uri strings to just their difference string
+    var baseParts = base.split('/');
+    baseParts.pop();
+    base = baseParts.join('/') + '/';
+    i = 0;
+    while (base.substr(i, 1) == uri.substr(i, 1))
+      i++;
+    while (base.substr(i, 1) != '/')
+      i--;
+    base = base.substr(i + 1);
+    uri = uri.substr(i + 1);
+
+    // each base folder difference is thus a backtrack
+    baseParts = base.split('/');
+    var uriParts = uri.split('/');
+    out = '';
+    while (baseParts.shift())
+      out += '../';
+    
+    // finally add uri parts
+    while (curPart = uriParts.shift())
+      out += curPart + '/';
+    
+    return out.substr(0, out.length - 1);
+  };
+  
+  var normalizeCSS = function(source, fromBase, toBase) {
+
+    fromBase = removeDoubleSlashes(fromBase);
+    toBase = removeDoubleSlashes(toBase);
+
+    var urlRegEx = /@import\s*("([^"]*)"|'([^']*)')|url\s*\((?!#)\s*(\s*"([^"]*)"|'([^']*)'|[^\)]*\s*)\s*\)/ig;
+    var result, url, source;
+
+    while (result = urlRegEx.exec(source)) {
+      url = result[3] || result[2] || result[5] || result[6] || result[4];
+      var newUrl;
+      newUrl = convertURIBase(url, fromBase, toBase);
+      var quoteLen = result[5] || result[6] ? 1 : 0;
+      source = source.substr(0, urlRegEx.lastIndex - url.length - quoteLen - 1) + newUrl + source.substr(urlRegEx.lastIndex - quoteLen - 1);
+      urlRegEx.lastIndex = urlRegEx.lastIndex + (newUrl.length - url.length);
+    }
+    
+    return source;
+  };
+  
+  normalizeCSS.convertURIBase = convertURIBase;
+  normalizeCSS.absoluteURI = absoluteURI;
+  normalizeCSS.relativeURI = relativeURI;
+  
+  return normalizeCSS;
+});
+//>>excludeEnd('excludeRequireCss')