jekyll-theme-chalk 0.1.1

data/_assets/yarn/webfontloader/src/core/nativefontwatchrunner.js

@@ -0,0 +1,69 @@
+goog.provide('webfont.NativeFontWatchRunner');
+
+goog.require('webfont.Font');
+
+goog.scope(function () {
+  /**
+  * @constructor
+  * @param {function(webfont.Font)} activeCallback
+  * @param {function(webfont.Font)} inactiveCallback
+  * @param {webfont.DomHelper} domHelper
+  * @param {webfont.Font} font
+  * @param {number=} opt_timeout
+  * @param {string=} opt_fontTestString
+  */
+  webfont.NativeFontWatchRunner = function(activeCallback, inactiveCallback, domHelper, font, opt_timeout, opt_fontTestString) {
+    this.activeCallback_ = activeCallback;
+    this.inactiveCallback_ = inactiveCallback;
+    this.font_ = font;
+    this.domHelper_ = domHelper;
+    this.timeout_ = opt_timeout || 3000;
+    this.fontTestString_ = opt_fontTestString || undefined;
+  };
+
+  var NativeFontWatchRunner = webfont.NativeFontWatchRunner;
+
+  NativeFontWatchRunner.prototype.start = function () {
+    var doc = this.domHelper_.getLoadWindow().document,
+        that = this;
+
+    var start = goog.now();
+
+    var loader = new Promise(function (resolve, reject) {
+      var check = function () {
+        var now = goog.now();
+
+        if (now - start >= that.timeout_) {
+          reject();
+        } else {
+          doc.fonts.load(that.font_.toCssString(), that.fontTestString_).then(function (fonts) {
+            if (fonts.length >= 1) {
+              resolve();
+            } else {
+              setTimeout(check, 25);
+            }
+          }, function () {
+            reject();
+          });
+        }
+      };
+
+      check();
+    });
+
+    var timeoutId = null,
+      timer = new Promise(function (resolve, reject) {
+        timeoutId = setTimeout(reject, that.timeout_);
+      });
+
+    Promise.race([timer, loader]).then(function () {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      that.activeCallback_(that.font_);
+    }, function () {
+      that.inactiveCallback_(that.font_);
+    });
+  };
+});

data/_assets/yarn/webfontloader/src/core/stylesheetwaiter.js

@@ -0,0 +1,48 @@
+goog.provide('webfont.StyleSheetWaiter');
+
+/**
+ * A utility class for handling callback from DomHelper.loadStylesheet().
+ *
+ * @constructor
+ */
+webfont.StyleSheetWaiter = function() {
+  /** @private @type {number} */
+  this.waitingCount_ = 0;
+  /** @private @type {Function} */
+  this.onReady_ = null;
+};
+
+goog.scope(function () {
+  var StyleSheetWaiter = webfont.StyleSheetWaiter;
+
+  /**
+   * @return {function(Error)}
+   */
+  StyleSheetWaiter.prototype.startWaitingLoad = function() {
+    var self = this;
+    self.waitingCount_++;
+    return function(error) {
+      self.waitingCount_--;
+      self.fireIfReady_();
+    };
+  };
+
+  /**
+   * @param {Function} fn
+   */
+  StyleSheetWaiter.prototype.waitWhileNeededThen = function(fn) {
+    this.onReady_ = fn;
+    this.fireIfReady_();
+  };
+
+  /**
+   * @private
+   */
+  StyleSheetWaiter.prototype.fireIfReady_ = function() {
+    var isReady = 0 == this.waitingCount_;
+    if (isReady && this.onReady_) {
+      this.onReady_();
+      this.onReady_ = null;
+    }
+  };
+});

data/_assets/yarn/webfontloader/src/core/webfont.js

@@ -0,0 +1,97 @@
+goog.provide('webfont.WebFont');
+
+goog.require('webfont.DomHelper');
+goog.require('webfont.EventDispatcher');
+goog.require('webfont.FontWatcher');
+goog.require('webfont.FontModuleLoader');
+
+/**
+ * @param {Window} mainWindow The main application window containing
+ *   webfontloader.js.
+ * @constructor
+ */
+webfont.WebFont = function(mainWindow) {
+  this.mainWindow_ = mainWindow;
+  this.fontModuleLoader_ = new webfont.FontModuleLoader();
+  this.moduleLoading_ = 0;
+  this.events_ = true;
+  this.classes_ = true;
+};
+
+goog.scope(function () {
+  var WebFont = webfont.WebFont,
+      DomHelper = webfont.DomHelper,
+      EventDispatcher = webfont.EventDispatcher,
+      FontWatcher = webfont.FontWatcher;
+
+  /**
+   * @param {string} name
+   * @param {webfont.FontModuleFactory} factory
+   */
+  WebFont.prototype.addModule = function(name, factory) {
+    this.fontModuleLoader_.addModuleFactory(name, factory);
+  };
+
+  /**
+   * @param {Object} configuration
+   */
+  WebFont.prototype.load = function(configuration) {
+    var context = configuration['context'] || this.mainWindow_;
+    this.domHelper_ = new DomHelper(this.mainWindow_, context);
+
+    this.events_ = configuration['events'] !== false;
+    this.classes_ = configuration['classes'] !== false;
+
+    var eventDispatcher = new EventDispatcher(
+        this.domHelper_,
+        configuration
+    );
+
+    this.load_(eventDispatcher, configuration);
+  };
+
+  /**
+   * @param {webfont.EventDispatcher} eventDispatcher
+   * @param {webfont.FontWatcher} fontWatcher
+   * @param {Array.<webfont.Font>} fonts
+   * @param {webfont.FontTestStrings=} opt_fontTestStrings
+   * @param {Object.<string, boolean>=} opt_metricCompatibleFonts
+   */
+  WebFont.prototype.onModuleReady_ = function(eventDispatcher, fontWatcher, fonts, opt_fontTestStrings, opt_metricCompatibleFonts) {
+    var allModulesLoaded = --this.moduleLoading_ == 0;
+
+    if (this.classes_ || this.events_) {
+      setTimeout(function () {
+        fontWatcher.watchFonts(fonts, opt_fontTestStrings || null, opt_metricCompatibleFonts || null, allModulesLoaded);
+      }, 0);
+    }
+  };
+
+  /**
+   * @param {webfont.EventDispatcher} eventDispatcher
+   * @param {Object} configuration
+   */
+  WebFont.prototype.load_ = function(eventDispatcher, configuration) {
+    var modules = [],
+        timeout = configuration['timeout'],
+        self = this;
+
+    // Immediately dispatch the loading event before initializing the modules
+    // so we know for sure that the loading event is synchronous.
+    eventDispatcher.dispatchLoading();
+
+    modules = this.fontModuleLoader_.getModules(configuration, this.domHelper_);
+
+    var fontWatcher = new webfont.FontWatcher(this.domHelper_, eventDispatcher, timeout);
+
+    this.moduleLoading_ = modules.length;
+
+    for (var i = 0, len = modules.length; i < len; i++) {
+      var module = modules[i];
+
+      module.load(function (fonts, opt_fontTestStrings, opt_metricCompatibleFonts) {
+        self.onModuleReady_(eventDispatcher, fontWatcher, fonts, opt_fontTestStrings, opt_metricCompatibleFonts);
+      });
+    }
+  };
+});

data/_assets/yarn/webfontloader/src/modules/custom.js

@@ -0,0 +1,63 @@
+goog.provide('webfont.modules.Custom');
+
+goog.require('webfont.Font');
+goog.require('webfont.StyleSheetWaiter');
+
+/**
+ *
+ * WebFont.load({
+ *   custom: {
+ *     families: ['Font1', 'Font2'],
+ *    urls: [ 'https://moo', 'https://meuh' ] }
+ * });
+ *
+ * @constructor
+ * @implements {webfont.FontModule}
+ */
+webfont.modules.Custom = function(domHelper, configuration) {
+  this.domHelper_ = domHelper;
+  this.configuration_ = configuration;
+};
+
+/**
+ * @const
+ * @type {string}
+ */
+webfont.modules.Custom.NAME = 'custom';
+
+goog.scope(function () {
+  var Custom = webfont.modules.Custom,
+      Font = webfont.Font,
+      StyleSheetWaiter = webfont.StyleSheetWaiter;
+
+  Custom.prototype.load = function(onReady) {
+    var i, len;
+    var urls = this.configuration_['urls'] || [];
+    var familiesConfiguration = this.configuration_['families'] || [];
+    var fontTestStrings = this.configuration_['testStrings'] || {};
+    var waiter = new StyleSheetWaiter();
+    for (i = 0, len = urls.length; i < len; i++) {
+      this.domHelper_.loadStylesheet(urls[i], waiter.startWaitingLoad());
+    }
+
+    var fonts = [];
+
+    for (i = 0, len = familiesConfiguration.length; i < len; i++) {
+      var components = familiesConfiguration[i].split(":");
+
+      if (components[1]) {
+        var variations = components[1].split(",");
+
+        for (var j = 0; j < variations.length; j += 1) {
+          fonts.push(new Font(components[0], variations[j]));
+        }
+      } else {
+        fonts.push(new Font(components[0]));
+      }
+    }
+
+    waiter.waitWhileNeededThen(function() {
+      onReady(fonts, fontTestStrings);
+    });
+  };
+});

data/_assets/yarn/webfontloader/src/modules/fontdeck.js

@@ -0,0 +1,66 @@
+goog.provide('webfont.modules.Fontdeck');
+
+goog.require('webfont.Font');
+
+/**
+ * @constructor
+ * @implements {webfont.FontModule}
+ */
+webfont.modules.Fontdeck = function(domHelper, configuration) {
+  this.domHelper_ = domHelper;
+  this.configuration_ = configuration;
+  this.fonts_ = [];
+};
+
+/**
+ * @const
+ * @type {string}
+ */
+webfont.modules.Fontdeck.NAME = 'fontdeck';
+webfont.modules.Fontdeck.HOOK = '__webfontfontdeckmodule__';
+webfont.modules.Fontdeck.API = 'https://f.fontdeck.com/s/css/js/';
+
+goog.scope(function () {
+  var Fontdeck = webfont.modules.Fontdeck,
+      Font = webfont.Font,
+      FontVariationDescription = webfont.FontVariationDescription;
+
+  Fontdeck.prototype.getScriptSrc = function(projectId) {
+    // For empty iframes, fall back to main window's hostname.
+    var hostname = this.domHelper_.getHostName();
+    var api = this.configuration_['api'] || webfont.modules.Fontdeck.API;
+    return api + hostname + '/' + projectId + '.js';
+  };
+
+  Fontdeck.prototype.load = function(onReady) {
+    var projectId = this.configuration_['id'];
+    var loadWindow = this.domHelper_.getLoadWindow();
+    var self = this;
+
+    if (projectId) {
+      // Provide data to Fontdeck for processing.
+      if (!loadWindow[webfont.modules.Fontdeck.HOOK]) {
+        loadWindow[webfont.modules.Fontdeck.HOOK] = {};
+      }
+
+      // Fontdeck will call this function to indicate support status
+      // and what fonts are provided.
+      loadWindow[webfont.modules.Fontdeck.HOOK][projectId] = function(fontdeckSupports, data) {
+        for (var i = 0, j = data['fonts'].length; i<j; ++i) {
+          var font = data['fonts'][i];
+          self.fonts_.push(new Font(font['name'], Font.parseCssVariation('font-weight:' + font['weight'] + ';font-style:' + font['style'])));
+        }
+        onReady(self.fonts_);
+      };
+
+      // Call the Fontdeck API.
+      this.domHelper_.loadScript(this.getScriptSrc(projectId), function (err) {
+        if (err) {
+          onReady([]);
+        }
+      });
+    } else {
+      onReady([]);
+    }
+  };
+});

data/_assets/yarn/webfontloader/src/modules/google/fontapiparser.js

@@ -0,0 +1,181 @@
+goog.provide('webfont.modules.google.FontApiParser');
+
+goog.require('webfont.Font');
+
+/**
+ * @constructor
+ */
+webfont.modules.google.FontApiParser = function(fontFamilies) {
+  this.fontFamilies_ = fontFamilies;
+  this.parsedFonts_ = [];
+  this.fontTestStrings_ = {};
+};
+
+webfont.modules.google.FontApiParser.INT_FONTS = {
+  'latin': webfont.FontWatchRunner.DEFAULT_TEST_STRING,
+  'latin-ext': '\u00E7\u00F6\u00FC\u011F\u015F',
+  'cyrillic': '\u0439\u044f\u0416',
+  'greek': '\u03b1\u03b2\u03a3',
+  'khmer': '\u1780\u1781\u1782',
+  'Hanuman': '\u1780\u1781\u1782' // For backward compatibility
+};
+
+webfont.modules.google.FontApiParser.WEIGHTS = {
+  'thin': '1',
+  'extralight': '2',
+  'extra-light': '2',
+  'ultralight': '2',
+  'ultra-light': '2',
+  'light': '3',
+  'regular': '4',
+  'book': '4',
+  'medium': '5',
+  'semi-bold': '6',
+  'semibold': '6',
+  'demi-bold': '6',
+  'demibold': '6',
+  'bold': '7',
+  'extra-bold': '8',
+  'extrabold': '8',
+  'ultra-bold': '8',
+  'ultrabold': '8',
+  'black': '9',
+  'heavy': '9',
+  'l': '3',
+  'r': '4',
+  'b': '7'
+};
+
+webfont.modules.google.FontApiParser.STYLES = {
+  'i': 'i',
+  'italic': 'i',
+  'n': 'n',
+  'normal': 'n'
+};
+
+webfont.modules.google.FontApiParser.VARIATION_MATCH =
+    new RegExp("^(thin|(?:(?:extra|ultra)-?)?light|regular|book|medium|" +
+        "(?:(?:semi|demi|extra|ultra)-?)?bold|black|heavy|l|r|b|[1-9]00)?(n|i" +
+        "|normal|italic)?$");
+
+goog.scope(function () {
+  var FontApiParser = webfont.modules.google.FontApiParser,
+      Font = webfont.Font;
+
+  FontApiParser.prototype.parse = function() {
+    var length = this.fontFamilies_.length;
+
+    for (var i = 0; i < length; i++) {
+      var elements = this.fontFamilies_[i].split(":");
+      var fontFamily = elements[0].replace(/\+/g, " ");
+      var variations = ['n4'];
+
+      if (elements.length >= 2) {
+        var fvds = this.parseVariations_(elements[1]);
+
+        if (fvds.length > 0) {
+          variations = fvds;
+        }
+        if (elements.length == 3) {
+          var subsets = this.parseSubsets_(elements[2]);
+          if (subsets.length > 0) {
+            var fontTestString = FontApiParser.INT_FONTS[subsets[0]];
+
+            if (fontTestString) {
+              this.fontTestStrings_[fontFamily] = fontTestString;
+            }
+          }
+        }
+      }
+
+      // For backward compatibility
+      if (!this.fontTestStrings_[fontFamily]) {
+        var hanumanTestString = FontApiParser.INT_FONTS[fontFamily];
+        if (hanumanTestString) {
+          this.fontTestStrings_[fontFamily] = hanumanTestString;
+        }
+      }
+
+      for (var j = 0; j < variations.length; j += 1) {
+        this.parsedFonts_.push(new Font(fontFamily, variations[j]));
+      }
+    }
+  };
+
+  FontApiParser.prototype.generateFontVariationDescription_ = function(variation) {
+    if (!variation.match(/^[\w-]+$/)) {
+      return '';
+    }
+    var normalizedVariation = variation.toLowerCase();
+    var groups = FontApiParser.VARIATION_MATCH.exec(normalizedVariation);
+    if (groups == null) {
+      return '';
+    }
+    var styleMatch = this.normalizeStyle_(groups[2]);
+    var weightMatch = this.normalizeWeight_(groups[1]);
+    return [styleMatch, weightMatch].join('');
+  };
+
+
+  FontApiParser.prototype.normalizeStyle_ = function(parsedStyle) {
+    if (parsedStyle == null || parsedStyle == '') {
+      return 'n';
+    }
+    return FontApiParser.STYLES[parsedStyle];
+  };
+
+
+  FontApiParser.prototype.normalizeWeight_ = function(parsedWeight) {
+    if (parsedWeight == null || parsedWeight == '') {
+      return '4';
+    }
+    var weight = FontApiParser.WEIGHTS[parsedWeight];
+    if (weight) {
+      return weight;
+    }
+    if (isNaN(parsedWeight)) {
+      return '4';
+    }
+    return parsedWeight.substr(0, 1);
+  };
+
+
+  FontApiParser.prototype.parseVariations_ = function(variations) {
+    var finalVariations = [];
+
+    if (!variations) {
+      return finalVariations;
+    }
+    var providedVariations = variations.split(",");
+    var length = providedVariations.length;
+
+    for (var i = 0; i < length; i++) {
+      var variation = providedVariations[i];
+      var fvd = this.generateFontVariationDescription_(variation);
+
+      if (fvd) {
+        finalVariations.push(fvd);
+      }
+    }
+    return finalVariations;
+  };
+
+
+  FontApiParser.prototype.parseSubsets_ = function(subsets) {
+    var finalSubsets = [];
+
+    if (!subsets) {
+      return finalSubsets;
+    }
+    return subsets.split(",");
+  };
+
+
+  FontApiParser.prototype.getFonts = function() {
+    return this.parsedFonts_;
+  };
+
+  FontApiParser.prototype.getFontTestStrings = function() {
+    return this.fontTestStrings_;
+  };
+});