jekyll-theme-hydejack 7.5.2 → 8.0.0

data/assets/bower_components/webfontloader/src/core/fontwatcher.js

@@ -1,171 +0,0 @@
-goog.provide('webfont.FontWatcher');
-
-goog.require('webfont.FontWatchRunner');
-goog.require('webfont.NativeFontWatchRunner');
-
-/**
- * @typedef {Object.<string, Array.<string>>}
- */
-webfont.FontTestStrings;
-
-/**
- * @constructor
- * @param {webfont.DomHelper} domHelper
- * @param {webfont.EventDispatcher} eventDispatcher
- * @param {number=} opt_timeout
- */
-webfont.FontWatcher = function(domHelper, eventDispatcher, opt_timeout) {
-  this.domHelper_ = domHelper;
-  this.eventDispatcher_ = eventDispatcher;
-  this.currentlyWatched_ = 0;
-  this.last_ = false;
-  this.success_ = false;
-  this.timeout_ = opt_timeout;
-};
-
-goog.scope(function () {
-  var FontWatcher = webfont.FontWatcher,
-      FontWatchRunner = webfont.FontWatchRunner,
-      NativeFontWatchRunner = webfont.NativeFontWatchRunner;
-
-  /**
-   * @type {null|boolean}
-   */
-  FontWatcher.SHOULD_USE_NATIVE_LOADER = null;
-
-  /**
-   * @return {string}
-   */
-  FontWatcher.getUserAgent = function () {
-    return window.navigator.userAgent;
-  };
-
-  /**
-   * @return {string}
-   */
-  FontWatcher.getVendor = function () {
-    return window.navigator.vendor;
-  };
-
-  /**
-   * Returns true if this browser has support for
-   * the CSS font loading API.
-   *
-   * @return {boolean}
-   */
-  FontWatcher.shouldUseNativeLoader = function () {
-    if (FontWatcher.SHOULD_USE_NATIVE_LOADER === null) {
-      if (!!window.FontFace) {
-        var match = /Gecko.*Firefox\/(\d+)/.exec(FontWatcher.getUserAgent());
-        var safari10Match = /OS X.*Version\/10\..*Safari/.exec(FontWatcher.getUserAgent()) && /Apple/.exec(FontWatcher.getVendor());
-
-        if (match) {
-          FontWatcher.SHOULD_USE_NATIVE_LOADER = parseInt(match[1], 10) > 42;
-        } else if (safari10Match) {
-          FontWatcher.SHOULD_USE_NATIVE_LOADER = false;
-        } else {
-          FontWatcher.SHOULD_USE_NATIVE_LOADER = true;
-        }
-      } else {
-        FontWatcher.SHOULD_USE_NATIVE_LOADER = false;
-      }
-    }
-    return FontWatcher.SHOULD_USE_NATIVE_LOADER;
-  };
-
-  /**
-   * Watches a set of font families.
-   * @param {Array.<webfont.Font>} fonts The fonts to watch.
-   * @param {webfont.FontTestStrings} fontTestStrings The font test strings for
-   *     each family.
-   * @param {Object.<String, boolean>} metricCompatibleFonts
-   * @param {boolean} last True if this is the last set of fonts to watch.
-   */
-  FontWatcher.prototype.watchFonts = function(fonts,
-      fontTestStrings, metricCompatibleFonts, last) {
-    var length = fonts.length,
-        testStrings = fontTestStrings || {};
-
-    if (length === 0 && last) {
-      this.eventDispatcher_.dispatchInactive();
-      return;
-    }
-
-    this.currentlyWatched_ += fonts.length;
-
-    if (last) {
-      this.last_ = last;
-    }
-
-    var i, fontWatchRunners = [];
-    for (i = 0; i < fonts.length; i++) {
-      var font = fonts[i],
-          testString = testStrings[font.getName()];
-
-      this.eventDispatcher_.dispatchFontLoading(font);
-
-      var fontWatchRunner = null;
-
-      if (FontWatcher.shouldUseNativeLoader()) {
-        fontWatchRunner = new NativeFontWatchRunner(
-            goog.bind(this.fontActive_, this),
-            goog.bind(this.fontInactive_, this),
-            this.domHelper_,
-            font,
-            this.timeout_,
-            testString
-          );
-      } else {
-        fontWatchRunner = new FontWatchRunner(
-          goog.bind(this.fontActive_, this),
-          goog.bind(this.fontInactive_, this),
-          this.domHelper_,
-          font,
-          this.timeout_,
-          metricCompatibleFonts,
-          testString
-        );
-      }
-
-      fontWatchRunners.push(fontWatchRunner);
-    }
-
-    for (i = 0; i < fontWatchRunners.length; i++) {
-      fontWatchRunners[i].start();
-    }
-  };
-
-  /**
-   * Called by a FontWatchRunner when a font has been detected as active.
-   * @param {webfont.Font} font
-   * @private
-   */
-  FontWatcher.prototype.fontActive_ = function(font) {
-    this.eventDispatcher_.dispatchFontActive(font);
-    this.success_ = true;
-    this.decreaseCurrentlyWatched_();
-  };
-
-  /**
-   * Called by a FontWatchRunner when a font has been detected as inactive.
-   * @param {webfont.Font} font
-   * @private
-   */
-  FontWatcher.prototype.fontInactive_ = function(font) {
-    this.eventDispatcher_.dispatchFontInactive(font);
-    this.decreaseCurrentlyWatched_();
-  };
-
-  /**
-   * @private
-   */
-  FontWatcher.prototype.decreaseCurrentlyWatched_ = function() {
-    if (--this.currentlyWatched_ == 0 && this.last_) {
-      if (this.success_) {
-        this.eventDispatcher_.dispatchActive();
-      } else {
-        this.eventDispatcher_.dispatchInactive();
-      }
-    }
-  };
-});

data/assets/bower_components/webfontloader/src/core/fontwatchrunner.js

@@ -1,249 +0,0 @@
-goog.provide('webfont.FontWatchRunner');
-
-goog.require('webfont.Font');
-goog.require('webfont.FontRuler');
-
-/**
- * @constructor
- * @param {function(webfont.Font)} activeCallback
- * @param {function(webfont.Font)} inactiveCallback
- * @param {webfont.DomHelper} domHelper
- * @param {webfont.Font} font
- * @param {number=} opt_timeout
- * @param {Object.<string, boolean>=} opt_metricCompatibleFonts
- * @param {string=} opt_fontTestString
- */
-webfont.FontWatchRunner = function(activeCallback, inactiveCallback, domHelper,
-    font, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString) {
-  this.activeCallback_ = activeCallback;
-  this.inactiveCallback_ = inactiveCallback;
-  this.domHelper_ = domHelper;
-  this.font_ = font;
-  this.fontTestString_ = opt_fontTestString || webfont.FontWatchRunner.DEFAULT_TEST_STRING;
-  this.lastResortWidths_ = {};
-  this.timeout_ = opt_timeout || 3000;
-
-  this.metricCompatibleFonts_ = opt_metricCompatibleFonts || null;
-
-  this.fontRulerA_ = null;
-  this.fontRulerB_ = null;
-  this.lastResortRulerA_ = null;
-  this.lastResortRulerB_ = null;
-
-  this.setupRulers_();
-};
-
-/**
- * @enum {string}
- * @const
- */
-webfont.FontWatchRunner.LastResortFonts = {
-  SERIF: 'serif',
-  SANS_SERIF: 'sans-serif'
-};
-
-/**
- * Default test string. Characters are chosen so that their widths vary a lot
- * between the fonts in the default stacks. We want each fallback stack
- * to always start out at a different width than the other.
- * @type {string}
- * @const
- */
-webfont.FontWatchRunner.DEFAULT_TEST_STRING = 'BESbswy';
-
-goog.scope(function () {
-  var FontWatchRunner = webfont.FontWatchRunner,
-      Font = webfont.Font,
-      FontRuler = webfont.FontRuler;
-
-  /**
-   * @type {null|boolean}
-   */
-  FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG = null;
-
-  /**
-   * @return {string}
-   */
-  FontWatchRunner.getUserAgent = function () {
-    return window.navigator.userAgent;
-  };
-
-  /**
-   * Returns true if this browser is WebKit and it has the fallback bug
-   * which is present in WebKit 536.11 and earlier.
-   *
-   * @return {boolean}
-   */
-  FontWatchRunner.hasWebKitFallbackBug = function () {
-    if (FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG === null) {
-      var match = /AppleWebKit\/([0-9]+)(?:\.([0-9]+))/.exec(FontWatchRunner.getUserAgent());
-
-      FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG = !!match &&
-                                          (parseInt(match[1], 10) < 536 ||
-                                           (parseInt(match[1], 10) === 536 &&
-                                            parseInt(match[2], 10) <= 11));
-    }
-    return FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG;
-  };
-
-  /**
-   * @private
-   */
-  FontWatchRunner.prototype.setupRulers_ = function() {
-    this.fontRulerA_ = new FontRuler(this.domHelper_, this.fontTestString_);
-    this.fontRulerB_ = new FontRuler(this.domHelper_, this.fontTestString_);
-    this.lastResortRulerA_ = new FontRuler(this.domHelper_, this.fontTestString_);
-    this.lastResortRulerB_ = new FontRuler(this.domHelper_, this.fontTestString_);
-
-    this.fontRulerA_.setFont(new Font(this.font_.getName() + ',' + FontWatchRunner.LastResortFonts.SERIF, this.font_.getVariation()));
-    this.fontRulerB_.setFont(new Font(this.font_.getName() + ',' + FontWatchRunner.LastResortFonts.SANS_SERIF, this.font_.getVariation()));
-    this.lastResortRulerA_.setFont(new Font(FontWatchRunner.LastResortFonts.SERIF, this.font_.getVariation()));
-    this.lastResortRulerB_.setFont(new Font(FontWatchRunner.LastResortFonts.SANS_SERIF, this.font_.getVariation()));
-
-    this.fontRulerA_.insert();
-    this.fontRulerB_.insert();
-    this.lastResortRulerA_.insert();
-    this.lastResortRulerB_.insert();
-  };
-
-  FontWatchRunner.prototype.start = function() {
-    this.lastResortWidths_[FontWatchRunner.LastResortFonts.SERIF] = this.lastResortRulerA_.getWidth();
-    this.lastResortWidths_[FontWatchRunner.LastResortFonts.SANS_SERIF] = this.lastResortRulerB_.getWidth();
-
-    this.started_ = goog.now();
-
-    this.check_();
-  };
-
-  /**
-   * Returns true if the given width matches the generic font family width.
-   *
-   * @private
-   * @param {number} width
-   * @param {string} lastResortFont
-   * @return {boolean}
-   */
-  FontWatchRunner.prototype.widthMatches_ = function(width, lastResortFont) {
-    return width === this.lastResortWidths_[lastResortFont];
-  };
-
-  /**
-   * Return true if the given widths match any of the generic font family
-   * widths.
-   *
-   * @private
-   * @param {number} a
-   * @param {number} b
-   * @return {boolean}
-   */
-  FontWatchRunner.prototype.widthsMatchLastResortWidths_ = function(a, b) {
-    for (var font in FontWatchRunner.LastResortFonts) {
-      if (FontWatchRunner.LastResortFonts.hasOwnProperty(font)) {
-        if (this.widthMatches_(a, FontWatchRunner.LastResortFonts[font]) &&
-            this.widthMatches_(b, FontWatchRunner.LastResortFonts[font])) {
-          return true;
-        }
-      }
-    }
-    return false;
-  };
-
-  /**
-   * @private
-   * Returns true if the loading has timed out.
-   * @return {boolean}
-   */
-  FontWatchRunner.prototype.hasTimedOut_ = function() {
-    return goog.now() - this.started_ >= this.timeout_;
-  };
-
-  /**
-   * Returns true if both fonts match the normal fallback fonts.
-   *
-   * @private
-   * @param {number} a
-   * @param {number} b
-   * @return {boolean}
-   */
-  FontWatchRunner.prototype.isFallbackFont_ = function (a, b) {
-    return this.widthMatches_(a, FontWatchRunner.LastResortFonts.SERIF) &&
-           this.widthMatches_(b, FontWatchRunner.LastResortFonts.SANS_SERIF);
-  };
-
-  /**
-   * Returns true if the WebKit bug is present and both widths match a last resort font.
-   *
-   * @private
-   * @param {number} a
-   * @param {number} b
-   * @return {boolean}
-   */
-  FontWatchRunner.prototype.isLastResortFont_ = function (a, b) {
-    return FontWatchRunner.hasWebKitFallbackBug() && this.widthsMatchLastResortWidths_(a, b);
-  };
-
-  /**
-   * Returns true if the current font is metric compatible. Also returns true
-   * if we do not have a list of metric compatible fonts.
-   *
-   * @private
-   * @return {boolean}
-   */
-  FontWatchRunner.prototype.isMetricCompatibleFont_ = function () {
-    return this.metricCompatibleFonts_ === null || this.metricCompatibleFonts_.hasOwnProperty(this.font_.getName());
-  };
-
-  /**
-   * Checks the width of the two spans against their original widths during each
-   * async loop. If the width of one of the spans is different than the original
-   * width, then we know that the font is rendering and finish with the active
-   * callback. If we wait more than 5 seconds and nothing has changed, we finish
-   * with the inactive callback.
-   *
-   * @private
-   */
-  FontWatchRunner.prototype.check_ = function() {
-    var widthA = this.fontRulerA_.getWidth();
-    var widthB = this.fontRulerB_.getWidth();
-
-    if (this.isFallbackFont_(widthA, widthB) || this.isLastResortFont_(widthA, widthB)) {
-      if (this.hasTimedOut_()) {
-        if (this.isLastResortFont_(widthA, widthB) && this.isMetricCompatibleFont_()) {
-          this.finish_(this.activeCallback_);
-        } else {
-          this.finish_(this.inactiveCallback_);
-        }
-     } else {
-        this.asyncCheck_();
-      }
-    } else {
-      this.finish_(this.activeCallback_);
-    }
-  };
-
-  /**
-   * @private
-   */
-  FontWatchRunner.prototype.asyncCheck_ = function() {
-    setTimeout(goog.bind(function () {
-      this.check_();
-    }, this), 50);
-  };
-
-  /**
-   * @private
-   * @param {function(webfont.Font)} callback
-   */
-  FontWatchRunner.prototype.finish_ = function(callback) {
-    // Remove elements and trigger callback (which adds active/inactive class) asynchronously to avoid reflow chain if
-    // several fonts are finished loading right after each other
-    setTimeout(goog.bind(function () {
-      this.fontRulerA_.remove();
-      this.fontRulerB_.remove();
-      this.lastResortRulerA_.remove();
-      this.lastResortRulerB_.remove();
-      callback(this.font_);
-    }, this), 0);
-  };
-
-});

data/assets/bower_components/webfontloader/src/core/initialize.js

@@ -1,97 +0,0 @@
-goog.provide('webfont');
-
-goog.require('webfont.WebFont');
-
-goog.require('webfont.modules.Typekit');
-goog.require('webfont.modules.Fontdeck');
-goog.require('webfont.modules.Monotype');
-goog.require('webfont.modules.Custom');
-goog.require('webfont.modules.google.GoogleFontApi');
-
-/**
- * @define {boolean}
- */
-var INCLUDE_CUSTOM_MODULE = false;
-
-/**
- * @define {boolean}
- */
-var INCLUDE_FONTDECK_MODULE = false;
-
-/**
- * @define {boolean}
- */
-var INCLUDE_MONOTYPE_MODULE = false;
-
-/**
- * @define {boolean}
- */
-var INCLUDE_TYPEKIT_MODULE = false;
-
-/**
- * @define {boolean}
- */
-var INCLUDE_GOOGLE_MODULE = false;
-
-/**
- * @define {string}
- */
-var WEBFONT = 'WebFont';
-
-/**
- * @define {string}
- */
-var WEBFONT_CONFIG = 'WebFontConfig';
-
-/**
- * @type {webfont.WebFont}
- */
-var webFontLoader = new webfont.WebFont(window);
-
-if (INCLUDE_CUSTOM_MODULE) {
-  webFontLoader.addModule(webfont.modules.Custom.NAME, function (configuration, domHelper) {
-    return new webfont.modules.Custom(domHelper, configuration);
-  });
-}
-
-if (INCLUDE_FONTDECK_MODULE) {
-  webFontLoader.addModule(webfont.modules.Fontdeck.NAME, function (configuration, domHelper) {
-    return new webfont.modules.Fontdeck(domHelper, configuration);
-  });
-}
-
-if (INCLUDE_MONOTYPE_MODULE) {
-  webFontLoader.addModule(webfont.modules.Monotype.NAME, function (configuration, domHelper) {
-    return new webfont.modules.Monotype(domHelper, configuration);
-  });
-}
-
-if (INCLUDE_TYPEKIT_MODULE) {
-  webFontLoader.addModule(webfont.modules.Typekit.NAME, function (configuration, domHelper) {
-    return new webfont.modules.Typekit(domHelper, configuration);
-  });
-}
-
-if (INCLUDE_GOOGLE_MODULE) {
-  webFontLoader.addModule(webfont.modules.google.GoogleFontApi.NAME, function (configuration, domHelper) {
-    return new webfont.modules.google.GoogleFontApi(domHelper, configuration);
-  });
-}
-
-var exports = {
-  'load': goog.bind(webFontLoader.load, webFontLoader)
-};
-
-if (typeof define === "function" && define.amd) {
-  define(function () {
-    return exports;
-  });
-} else if (typeof module !== "undefined" && module.exports) {
-  module.exports = exports;
-} else {
-  window[WEBFONT] = exports;
-
-  if (window[WEBFONT_CONFIG]) {
-    webFontLoader.load(window[WEBFONT_CONFIG]);
-  }
-}