Merge pull request #7 from lxndrblz/CSP-issues

Alexander Bilz

17.03.2020 60a3e422f7d211a8e0e4ccd6486daf350766eaf5

Merge pull request #7 from lxndrblz/CSP-issues

Make theme compliant to strict CSP

 assets/css/medium-zoom.css

 assets/css/style.css

 assets/js/jquery-appear.js

New file
@@ -0,0 +1,124 @@
/*
 * jQuery appear plugin
 *
 * Copyright (c) 2012 Andrey Sidorov
 * licensed under MIT license.
 *
 * https://github.com/morr/jquery.appear/
 *
 * Version: 0.4
 */
(function($) {
    var selectors = [];
  
    var check_binded = false;
    var check_lock = false;
    var defaults = {
      interval: 250,
      force_process: false
    };
    var $window = $(window);
  
    var $prior_appeared = [];
  
    function appeared(selector) {
      return $(selector).filter(function() {
        return $(this).is(':appeared');
      });
    }
  
    function process() {
      check_lock = false;
      for (var index = 0, selectorsLength = selectors.length; index < selectorsLength; index++) {
        var $appeared = appeared(selectors[index]);
  
        $appeared.trigger('appear', [$appeared]);
  
        if ($prior_appeared[index]) {
          var $disappeared = $prior_appeared[index].not($appeared);
          $disappeared.trigger('disappear', [$disappeared]);
        }
        $prior_appeared[index] = $appeared;
      }
    }
  
    function add_selector(selector) {
      selectors.push(selector);
      $prior_appeared.push();
    }
  
    // ":appeared" custom filter
    $.expr.pseudos.appeared = $.expr.createPseudo(function(arg) {
      return function(element) {
        var $element = $(element);
        if (!$element.is(':visible')) {
          return false;
        }
  
        var window_left = $window.scrollLeft();
        var window_top = $window.scrollTop();
        var offset = $element.offset();
        var left = offset.left;
        var top = offset.top;
  
        if (top + $element.height() >= window_top &&
            top - ($element.data('appear-top-offset') || 0) <= window_top + $window.height() &&
            left + $element.width() >= window_left &&
            left - ($element.data('appear-left-offset') || 0) <= window_left + $window.width()) {
          return true;
        } else {
          return false;
        }
      };
    });
  
    $.fn.extend({
      // watching for element's appearance in browser viewport
      appear: function(selector, options) {
        $.appear(this, options);
        return this;
      }
    });
  
    $.extend({
      appear: function(selector, options) {
        var opts = $.extend({}, defaults, options || {});
  
        if (!check_binded) {
          var on_check = function() {
            if (check_lock) {
              return;
            }
            check_lock = true;
  
            setTimeout(process, opts.interval);
          };
  
          $(window).scroll(on_check).resize(on_check);
          check_binded = true;
        }
  
        if (opts.force_process) {
          setTimeout(process, opts.interval);
        }
  
        add_selector(selector);
      },
      // force elements's appearance check
      force_appear: function() {
        if (check_binded) {
          process();
          return true;
        }
        return false;
      }
    });
  })(function() {
    if (typeof module !== 'undefined') {
      // Node
      return require('jquery');
    } else {
      return jQuery;
    }
  }());
  

 assets/js/jquery-migrate.js

New file
@@ -0,0 +1,838 @@
/*!
 * jQuery Migrate - v3.3.0 - 2020-05-05T01:57Z
 * Copyright OpenJS Foundation and other contributors
 */
( function( factory ) {
    "use strict";

    if ( typeof define === "function" && define.amd ) {

        // AMD. Register as an anonymous module.
        define( [ "jquery" ], function( jQuery ) {
            return factory( jQuery, window );
        } );
    } else if ( typeof module === "object" && module.exports ) {

        // Node/CommonJS
        // eslint-disable-next-line no-undef
        module.exports = factory( require( "jquery" ), window );
    } else {

        // Browser globals
        factory( jQuery, window );
    }
} )( function( jQuery, window ) {
"use strict";

jQuery.migrateVersion = "3.3.0";

// Returns 0 if v1 == v2, -1 if v1 < v2, 1 if v1 > v2
function compareVersions( v1, v2 ) {
    var i,
        rVersionParts = /^(\d+)\.(\d+)\.(\d+)/,
        v1p = rVersionParts.exec( v1 ) || [ ],
        v2p = rVersionParts.exec( v2 ) || [ ];

    for ( i = 1; i <= 3; i++ ) {
        if ( +v1p[ i ] > +v2p[ i ] ) {
            return 1;
        }
        if ( +v1p[ i ] < +v2p[ i ] ) {
            return -1;
        }
    }
    return 0;
}

function jQueryVersionSince( version ) {
    return compareVersions( jQuery.fn.jquery, version ) >= 0;
}

( function() {

    // Support: IE9 only
    // IE9 only creates console object when dev tools are first opened
    // IE9 console is a host object, callable but doesn't have .apply()
    if ( !window.console || !window.console.log ) {
        return;
    }

    // Need jQuery 3.0.0+ and no older Migrate loaded
    if ( !jQuery || !jQueryVersionSince( "3.0.0" ) ) {
        window.console.log( "JQMIGRATE: jQuery 3.0.0+ REQUIRED" );
    }
    if ( jQuery.migrateWarnings ) {
        window.console.log( "JQMIGRATE: Migrate plugin loaded multiple times" );
    }

    // Show a message on the console so devs know we're active
    window.console.log( "JQMIGRATE: Migrate is installed" +
        ( jQuery.migrateMute ? "" : " with logging active" ) +
        ", version " + jQuery.migrateVersion );

} )();

var warnedAbout = {};

// By default each warning is only reported once.
jQuery.migrateDeduplicateWarnings = true;

// List of warnings already given; public read only
jQuery.migrateWarnings = [];

// Set to false to disable traces that appear with warnings
if ( jQuery.migrateTrace === undefined ) {
    jQuery.migrateTrace = true;
}

// Forget any warnings we've already given; public
jQuery.migrateReset = function() {
    warnedAbout = {};
    jQuery.migrateWarnings.length = 0;
};

function migrateWarn( msg ) {
    var console = window.console;
    if ( !jQuery.migrateDeduplicateWarnings || !warnedAbout[ msg ] ) {
        warnedAbout[ msg ] = true;
        jQuery.migrateWarnings.push( msg );
        if ( console && console.warn && !jQuery.migrateMute ) {
            console.warn( "JQMIGRATE: " + msg );
            if ( jQuery.migrateTrace && console.trace ) {
                console.trace();
            }
        }
    }
}

function migrateWarnProp( obj, prop, value, msg ) {
    Object.defineProperty( obj, prop, {
        configurable: true,
        enumerable: true,
        get: function() {
            migrateWarn( msg );
            return value;
        },
        set: function( newValue ) {
            migrateWarn( msg );
            value = newValue;
        }
    } );
}

function migrateWarnFunc( obj, prop, newFunc, msg ) {
    obj[ prop ] = function() {
        migrateWarn( msg );
        return newFunc.apply( this, arguments );
    };
}

if ( window.document.compatMode === "BackCompat" ) {

    // JQuery has never supported or tested Quirks Mode
    migrateWarn( "jQuery is not compatible with Quirks Mode" );
}

var findProp,
    class2type = {},
    oldInit = jQuery.fn.init,
    oldFind = jQuery.find,

    rattrHashTest = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/,
    rattrHashGlob = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/g,

    // Support: Android <=4.0 only
    // Make sure we trim BOM and NBSP
    rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;

jQuery.fn.init = function( arg1 ) {
    var args = Array.prototype.slice.call( arguments );

    if ( typeof arg1 === "string" && arg1 === "#" ) {

        // JQuery( "#" ) is a bogus ID selector, but it returned an empty set before jQuery 3.0
        migrateWarn( "jQuery( '#' ) is not a valid selector" );
        args[ 0 ] = [];
    }

    return oldInit.apply( this, args );
};
jQuery.fn.init.prototype = jQuery.fn;

jQuery.find = function( selector ) {
    var args = Array.prototype.slice.call( arguments );

    // Support: PhantomJS 1.x
    // String#match fails to match when used with a //g RegExp, only on some strings
    if ( typeof selector === "string" && rattrHashTest.test( selector ) ) {

        // The nonstandard and undocumented unquoted-hash was removed in jQuery 1.12.0
        // First see if qS thinks it's a valid selector, if so avoid a false positive
        try {
            window.document.querySelector( selector );
        } catch ( err1 ) {

            // Didn't *look* valid to qSA, warn and try quoting what we think is the value
            selector = selector.replace( rattrHashGlob, function( _, attr, op, value ) {
                return "[" + attr + op + "\"" + value + "\"]";
            } );

            // If the regexp *may* have created an invalid selector, don't update it
            // Note that there may be false alarms if selector uses jQuery extensions
            try {
                window.document.querySelector( selector );
                migrateWarn( "Attribute selector with '#' must be quoted: " + args[ 0 ] );
                args[ 0 ] = selector;
            } catch ( err2 ) {
                migrateWarn( "Attribute selector with '#' was not fixed: " + args[ 0 ] );
            }
        }
    }

    return oldFind.apply( this, args );
};

// Copy properties attached to original jQuery.find method (e.g. .attr, .isXML)
for ( findProp in oldFind ) {
    if ( Object.prototype.hasOwnProperty.call( oldFind, findProp ) ) {
        jQuery.find[ findProp ] = oldFind[ findProp ];
    }
}

// The number of elements contained in the matched element set
migrateWarnFunc( jQuery.fn, "size", function() {
    return this.length;
},
"jQuery.fn.size() is deprecated and removed; use the .length property" );

migrateWarnFunc( jQuery, "parseJSON", function() {
    return JSON.parse.apply( null, arguments );
},
"jQuery.parseJSON is deprecated; use JSON.parse" );

migrateWarnFunc( jQuery, "holdReady", jQuery.holdReady,
    "jQuery.holdReady is deprecated" );

migrateWarnFunc( jQuery, "unique", jQuery.uniqueSort,
    "jQuery.unique is deprecated; use jQuery.uniqueSort" );

// Now jQuery.expr.pseudos is the standard incantation
migrateWarnProp( jQuery.expr, "filters", jQuery.expr.pseudos,
    "jQuery.expr.filters is deprecated; use jQuery.expr.pseudos" );
migrateWarnProp( jQuery.expr, ":", jQuery.expr.pseudos,
    "jQuery.expr[':'] is deprecated; use jQuery.expr.pseudos" );

// Prior to jQuery 3.1.1 there were internal refs so we don't warn there
if ( jQueryVersionSince( "3.1.1" ) ) {
    migrateWarnFunc( jQuery, "trim", function( text ) {
        return text == null ?
            "" :
            ( text + "" ).replace( rtrim, "" );
    },
    "jQuery.trim is deprecated; use String.prototype.trim" );
}

// Prior to jQuery 3.2 there were internal refs so we don't warn there
if ( jQueryVersionSince( "3.2.0" ) ) {
    migrateWarnFunc( jQuery, "nodeName", function( elem, name ) {
        return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
    },
    "jQuery.nodeName is deprecated" );
}

if ( jQueryVersionSince( "3.3.0" ) ) {

    migrateWarnFunc( jQuery, "isNumeric", function( obj ) {

            // As of jQuery 3.0, isNumeric is limited to
            // strings and numbers (primitives or objects)
            // that can be coerced to finite numbers (gh-2662)
            var type = typeof obj;
            return ( type === "number" || type === "string" ) &&

                // parseFloat NaNs numeric-cast false positives ("")
                // ...but misinterprets leading-number strings, e.g. hex literals ("0x...")
                // subtraction forces infinities to NaN
                !isNaN( obj - parseFloat( obj ) );
        },
        "jQuery.isNumeric() is deprecated"
    );

    // Populate the class2type map
    jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".
        split( " " ),
    function( _, name ) {
        class2type[ "[object " + name + "]" ] = name.toLowerCase();
    } );

    migrateWarnFunc( jQuery, "type", function( obj ) {
        if ( obj == null ) {
            return obj + "";
        }

        // Support: Android <=2.3 only (functionish RegExp)
        return typeof obj === "object" || typeof obj === "function" ?
            class2type[ Object.prototype.toString.call( obj ) ] || "object" :
            typeof obj;
    },
    "jQuery.type is deprecated" );

    migrateWarnFunc( jQuery, "isFunction",
        function( obj ) {
            return typeof obj === "function";
        },
        "jQuery.isFunction() is deprecated" );

    migrateWarnFunc( jQuery, "isWindow",
        function( obj ) {
            return obj != null && obj === obj.window;
        },
        "jQuery.isWindow() is deprecated"
    );

    migrateWarnFunc( jQuery, "isArray", Array.isArray,
        "jQuery.isArray is deprecated; use Array.isArray"
    );
}

// Support jQuery slim which excludes the ajax module
if ( jQuery.ajax ) {

var oldAjax = jQuery.ajax;

jQuery.ajax = function( ) {
    var jQXHR = oldAjax.apply( this, arguments );

    // Be sure we got a jQXHR (e.g., not sync)
    if ( jQXHR.promise ) {
        migrateWarnFunc( jQXHR, "success", jQXHR.done,
            "jQXHR.success is deprecated and removed" );
        migrateWarnFunc( jQXHR, "error", jQXHR.fail,
            "jQXHR.error is deprecated and removed" );
        migrateWarnFunc( jQXHR, "complete", jQXHR.always,
            "jQXHR.complete is deprecated and removed" );
    }

    return jQXHR;
};

}

var oldRemoveAttr = jQuery.fn.removeAttr,
    oldToggleClass = jQuery.fn.toggleClass,
    rmatchNonSpace = /\S+/g;

jQuery.fn.removeAttr = function( name ) {
    var self = this;

    jQuery.each( name.match( rmatchNonSpace ), function( _i, attr ) {
        if ( jQuery.expr.match.bool.test( attr ) ) {
            migrateWarn( "jQuery.fn.removeAttr no longer sets boolean properties: " + attr );
            self.prop( attr, false );
        }
    } );

    return oldRemoveAttr.apply( this, arguments );
};

jQuery.fn.toggleClass = function( state ) {

    // Only deprecating no-args or single boolean arg
    if ( state !== undefined && typeof state !== "boolean" ) {
        return oldToggleClass.apply( this, arguments );
    }

    migrateWarn( "jQuery.fn.toggleClass( boolean ) is deprecated" );

    // Toggle entire class name of each element
    return this.each( function() {
        var className = this.getAttribute && this.getAttribute( "class" ) || "";

        if ( className ) {
            jQuery.data( this, "__className__", className );
        }

        // If the element has a class name or if we're passed `false`,
        // then remove the whole classname (if there was one, the above saved it).
        // Otherwise bring back whatever was previously saved (if anything),
        // falling back to the empty string if nothing was stored.
        if ( this.setAttribute ) {
            this.setAttribute( "class",
                className || state === false ?
                "" :
                jQuery.data( this, "__className__" ) || ""
            );
        }
    } );
};

function camelCase( string ) {
    return string.replace( /-([a-z])/g, function( _, letter ) {
        return letter.toUpperCase();
    } );
}

var oldFnCss,
    internalSwapCall = false,
    ralphaStart = /^[a-z]/,

    // The regex visualized:
    //
    //                         /----------\
    //                        |            |    /-------\
    //                        |  / Top  \  |   |         |
    //         /--- Border ---+-| Right  |-+---+- Width -+---\
    //        |                 | Bottom |                    |
    //        |                  \ Left /                     |
    //        |                                               |
    //        |                              /----------\     |
    //        |          /-------------\    |            |    |- END
    //        |         |               |   |  / Top  \  |    |
    //        |         |  / Margin  \  |   | | Right  | |    |
    //        |---------+-|           |-+---+-| Bottom |-+----|
    //        |            \ Padding /         \ Left /       |
    // BEGIN -|                                               |
    //        |                /---------\                    |
    //        |               |           |                   |
    //        |               |  / Min \  |    / Width  \     |
    //         \--------------+-|       |-+---|          |---/
    //                           \ Max /       \ Height /
    rautoPx = /^(?:Border(?:Top|Right|Bottom|Left)?(?:Width|)|(?:Margin|Padding)?(?:Top|Right|Bottom|Left)?|(?:Min|Max)?(?:Width|Height))$/;

// If this version of jQuery has .swap(), don't false-alarm on internal uses
if ( jQuery.swap ) {
    jQuery.each( [ "height", "width", "reliableMarginRight" ], function( _, name ) {
        var oldHook = jQuery.cssHooks[ name ] && jQuery.cssHooks[ name ].get;

        if ( oldHook ) {
            jQuery.cssHooks[ name ].get = function() {
                var ret;

                internalSwapCall = true;
                ret = oldHook.apply( this, arguments );
                internalSwapCall = false;
                return ret;
            };
        }
    } );
}

jQuery.swap = function( elem, options, callback, args ) {
    var ret, name,
        old = {};

    if ( !internalSwapCall ) {
        migrateWarn( "jQuery.swap() is undocumented and deprecated" );
    }

    // Remember the old values, and insert the new ones
    for ( name in options ) {
        old[ name ] = elem.style[ name ];
        elem.style[ name ] = options[ name ];
    }

    ret = callback.apply( elem, args || [] );

    // Revert the old values
    for ( name in options ) {
        elem.style[ name ] = old[ name ];
    }

    return ret;
};

if ( jQueryVersionSince( "3.4.0" ) && typeof Proxy !== "undefined" ) {

    jQuery.cssProps = new Proxy( jQuery.cssProps || {}, {
        set: function() {
            migrateWarn( "JQMIGRATE: jQuery.cssProps is deprecated" );
            return Reflect.set.apply( this, arguments );
        }
    } );
}

// Create a dummy jQuery.cssNumber if missing. It won't be used by jQuery but
// it will prevent code adding new keys to it unconditionally from crashing.
if ( !jQuery.cssNumber ) {
    jQuery.cssNumber = {};
}

function isAutoPx( prop ) {

    // The first test is used to ensure that:
    // 1. The prop starts with a lowercase letter (as we uppercase it for the second regex).
    // 2. The prop is not empty.
    return ralphaStart.test( prop ) &&
        rautoPx.test( prop[ 0 ].toUpperCase() + prop.slice( 1 ) );
}

oldFnCss = jQuery.fn.css;

jQuery.fn.css = function( name, value ) {
    var origThis = this;
    if ( typeof name !== "string" ) {
        jQuery.each( name, function( n, v ) {
            jQuery.fn.css.call( origThis, n, v );
        } );
    }
    if ( typeof value === "number" && !isAutoPx( camelCase( name ) ) ) {
        migrateWarn( "Use of number-typed values is deprecated in jQuery.fn.css" );
    }

    return oldFnCss.apply( this, arguments );
};

var oldData = jQuery.data;

jQuery.data = function( elem, name, value ) {
    var curData, sameKeys, key;

    // Name can be an object, and each entry in the object is meant to be set as data
    if ( name && typeof name === "object" && arguments.length === 2 ) {
        curData = jQuery.hasData( elem ) && oldData.call( this, elem );
        sameKeys = {};
        for ( key in name ) {
            if ( key !== camelCase( key ) ) {
                migrateWarn( "jQuery.data() always sets/gets camelCased names: " + key );
                curData[ key ] = name[ key ];
            } else {
                sameKeys[ key ] = name[ key ];
            }
        }

        oldData.call( this, elem, sameKeys );

        return name;
    }

    // If the name is transformed, look for the un-transformed name in the data object
    if ( name && typeof name === "string" && name !== camelCase( name ) ) {
        curData = jQuery.hasData( elem ) && oldData.call( this, elem );
        if ( curData && name in curData ) {
            migrateWarn( "jQuery.data() always sets/gets camelCased names: " + name );
            if ( arguments.length > 2 ) {
                curData[ name ] = value;
            }
            return curData[ name ];
        }
    }

    return oldData.apply( this, arguments );
};

// Support jQuery slim which excludes the effects module
if ( jQuery.fx ) {

var intervalValue, intervalMsg,
    oldTweenRun = jQuery.Tween.prototype.run,
    linearEasing = function( pct ) {
        return pct;
    };

jQuery.Tween.prototype.run = function( ) {
    if ( jQuery.easing[ this.easing ].length > 1 ) {
        migrateWarn(
            "'jQuery.easing." + this.easing.toString() + "' should use only one argument"
        );

        jQuery.easing[ this.easing ] = linearEasing;
    }

    oldTweenRun.apply( this, arguments );
};

intervalValue = jQuery.fx.interval || 13;
intervalMsg = "jQuery.fx.interval is deprecated";

// Support: IE9, Android <=4.4
// Avoid false positives on browsers that lack rAF
// Don't warn if document is hidden, jQuery uses setTimeout (#292)
if ( window.requestAnimationFrame ) {
    Object.defineProperty( jQuery.fx, "interval", {
        configurable: true,
        enumerable: true,
        get: function() {
            if ( !window.document.hidden ) {
                migrateWarn( intervalMsg );
            }
            return intervalValue;
        },
        set: function( newValue ) {
            migrateWarn( intervalMsg );
            intervalValue = newValue;
        }
    } );
}

}

var oldLoad = jQuery.fn.load,
    oldEventAdd = jQuery.event.add,
    originalFix = jQuery.event.fix;

jQuery.event.props = [];
jQuery.event.fixHooks = {};

migrateWarnProp( jQuery.event.props, "concat", jQuery.event.props.concat,
    "jQuery.event.props.concat() is deprecated and removed" );

jQuery.event.fix = function( originalEvent ) {
    var event,
        type = originalEvent.type,
        fixHook = this.fixHooks[ type ],
        props = jQuery.event.props;

    if ( props.length ) {
        migrateWarn( "jQuery.event.props are deprecated and removed: " + props.join() );
        while ( props.length ) {
            jQuery.event.addProp( props.pop() );
        }
    }

    if ( fixHook && !fixHook._migrated_ ) {
        fixHook._migrated_ = true;
        migrateWarn( "jQuery.event.fixHooks are deprecated and removed: " + type );
        if ( ( props = fixHook.props ) && props.length ) {
            while ( props.length ) {
                jQuery.event.addProp( props.pop() );
            }
        }
    }

    event = originalFix.call( this, originalEvent );

    return fixHook && fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
};

jQuery.event.add = function( elem, types ) {

    // This misses the multiple-types case but that seems awfully rare
    if ( elem === window && types === "load" && window.document.readyState === "complete" ) {
        migrateWarn( "jQuery(window).on('load'...) called after load event occurred" );
    }
    return oldEventAdd.apply( this, arguments );
};

jQuery.each( [ "load", "unload", "error" ], function( _, name ) {

    jQuery.fn[ name ] = function() {
        var args = Array.prototype.slice.call( arguments, 0 );

        // If this is an ajax load() the first arg should be the string URL;
        // technically this could also be the "Anything" arg of the event .load()
        // which just goes to show why this dumb signature has been deprecated!
        // jQuery custom builds that exclude the Ajax module justifiably die here.
        if ( name === "load" && typeof args[ 0 ] === "string" ) {
            return oldLoad.apply( this, args );
        }

        migrateWarn( "jQuery.fn." + name + "() is deprecated" );

        args.splice( 0, 0, name );
        if ( arguments.length ) {
            return this.on.apply( this, args );
        }

        // Use .triggerHandler here because:
        // - load and unload events don't need to bubble, only applied to window or image
        // - error event should not bubble to window, although it does pre-1.7
        // See http://bugs.jquery.com/ticket/11820
        this.triggerHandler.apply( this, args );
        return this;
    };

} );

jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
    "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
    "change select submit keydown keypress keyup contextmenu" ).split( " " ),
    function( _i, name ) {

    // Handle event binding
    jQuery.fn[ name ] = function( data, fn ) {
        migrateWarn( "jQuery.fn." + name + "() event shorthand is deprecated" );
        return arguments.length > 0 ?
            this.on( name, null, data, fn ) :
            this.trigger( name );
    };
} );

// Trigger "ready" event only once, on document ready
jQuery( function() {
    jQuery( window.document ).triggerHandler( "ready" );
} );

jQuery.event.special.ready = {
    setup: function() {
        if ( this === window.document ) {
            migrateWarn( "'ready' event is deprecated" );
        }
    }
};

jQuery.fn.extend( {

    bind: function( types, data, fn ) {
        migrateWarn( "jQuery.fn.bind() is deprecated" );
        return this.on( types, null, data, fn );
    },
    unbind: function( types, fn ) {
        migrateWarn( "jQuery.fn.unbind() is deprecated" );
        return this.off( types, null, fn );
    },
    delegate: function( selector, types, data, fn ) {
        migrateWarn( "jQuery.fn.delegate() is deprecated" );
        return this.on( types, selector, data, fn );
    },
    undelegate: function( selector, types, fn ) {
        migrateWarn( "jQuery.fn.undelegate() is deprecated" );
        return arguments.length === 1 ?
            this.off( selector, "**" ) :
            this.off( types, selector || "**", fn );
    },
    hover: function( fnOver, fnOut ) {
        migrateWarn( "jQuery.fn.hover() is deprecated" );
        return this.on( "mouseenter", fnOver ).on( "mouseleave", fnOut || fnOver );
    }
} );

var rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
    origHtmlPrefilter = jQuery.htmlPrefilter,
    makeMarkup = function( html ) {
        var doc = window.document.implementation.createHTMLDocument( "" );
        doc.body.innerHTML = html;
        return doc.body && doc.body.innerHTML;
    },
    warnIfChanged = function( html ) {
        var changed = html.replace( rxhtmlTag, "<$1></$2>" );
        if ( changed !== html && makeMarkup( html ) !== makeMarkup( changed ) ) {
            migrateWarn( "HTML tags must be properly nested and closed: " + html );
        }
    };

jQuery.UNSAFE_restoreLegacyHtmlPrefilter = function() {
    jQuery.htmlPrefilter = function( html ) {
        warnIfChanged( html );
        return html.replace( rxhtmlTag, "<$1></$2>" );
    };
};

jQuery.htmlPrefilter = function( html ) {
    warnIfChanged( html );
    return origHtmlPrefilter( html );
};

var oldOffset = jQuery.fn.offset;

jQuery.fn.offset = function() {
    var docElem,
        elem = this[ 0 ],
        bogus = { top: 0, left: 0 };

    if ( !elem || !elem.nodeType ) {
        migrateWarn( "jQuery.fn.offset() requires a valid DOM element" );
        return undefined;
    }

    docElem = ( elem.ownerDocument || window.document ).documentElement;
    if ( !jQuery.contains( docElem, elem ) ) {
        migrateWarn( "jQuery.fn.offset() requires an element connected to a document" );
        return bogus;
    }

    return oldOffset.apply( this, arguments );
};

// Support jQuery slim which excludes the ajax module
// The jQuery.param patch is about respecting `jQuery.ajaxSettings.traditional`
// so it doesn't make sense for the slim build.
if ( jQuery.ajax ) {

var oldParam = jQuery.param;

jQuery.param = function( data, traditional ) {
    var ajaxTraditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;

    if ( traditional === undefined && ajaxTraditional ) {

        migrateWarn( "jQuery.param() no longer uses jQuery.ajaxSettings.traditional" );
        traditional = ajaxTraditional;
    }

    return oldParam.call( this, data, traditional );
};

}

var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack;

jQuery.fn.andSelf = function() {
    migrateWarn( "jQuery.fn.andSelf() is deprecated and removed, use jQuery.fn.addBack()" );
    return oldSelf.apply( this, arguments );
};

// Support jQuery slim which excludes the deferred module in jQuery 4.0+
if ( jQuery.Deferred ) {

var oldDeferred = jQuery.Deferred,
    tuples = [

        // Action, add listener, callbacks, .then handlers, final state
        [ "resolve", "done", jQuery.Callbacks( "once memory" ),
            jQuery.Callbacks( "once memory" ), "resolved" ],
        [ "reject", "fail", jQuery.Callbacks( "once memory" ),
            jQuery.Callbacks( "once memory" ), "rejected" ],
        [ "notify", "progress", jQuery.Callbacks( "memory" ),
            jQuery.Callbacks( "memory" ) ]
    ];

jQuery.Deferred = function( func ) {
    var deferred = oldDeferred(),
        promise = deferred.promise();

    deferred.pipe = promise.pipe = function( /* fnDone, fnFail, fnProgress */ ) {
        var fns = arguments;

        migrateWarn( "deferred.pipe() is deprecated" );

        return jQuery.Deferred( function( newDefer ) {
            jQuery.each( tuples, function( i, tuple ) {
                var fn = typeof fns[ i ] === "function" && fns[ i ];

                // Deferred.done(function() { bind to newDefer or newDefer.resolve })
                // deferred.fail(function() { bind to newDefer or newDefer.reject })
                // deferred.progress(function() { bind to newDefer or newDefer.notify })
                deferred[ tuple[ 1 ] ]( function() {
                    var returned = fn && fn.apply( this, arguments );
                    if ( returned && typeof returned.promise === "function" ) {
                        returned.promise()
                            .done( newDefer.resolve )
                            .fail( newDefer.reject )
                            .progress( newDefer.notify );
                    } else {
                        newDefer[ tuple[ 0 ] + "With" ](
                            this === promise ? newDefer.promise() : this,
                            fn ? [ returned ] : arguments
                        );
                    }
                } );
            } );
            fns = null;
        } ).promise();

    };

    if ( func ) {
        func.call( deferred, deferred );
    }

    return deferred;
};

// Preserve handler of uncaught exceptions in promise chains
jQuery.Deferred.exceptionHook = oldDeferred.exceptionHook;

}

return jQuery;
} );

 assets/js/jquery.js

New file
Diff too large

 assets/js/medium-zoom.js

New file
@@ -0,0 +1,457 @@
/*! medium-zoom 1.0.5 | MIT License | https://github.com/francoischalifour/medium-zoom */
(function(global, factory) {
    typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = global || self, 
    global.mediumZoom = factory());
  })(this, function() {
    "use strict";
    var _extends = Object.assign || function(target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];
        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }
      return target;
    };
    var isSupported = function isSupported(node) {
      return node.tagName === "IMG";
    };
    var isNodeList = function isNodeList(selector) {
      return NodeList.prototype.isPrototypeOf(selector);
    };
    var isNode = function isNode(selector) {
      return selector && selector.nodeType === 1;
    };
    var isSvg = function isSvg(image) {
      var source = image.currentSrc || image.src;
      return source.substr(-4).toLowerCase() === ".svg";
    };
    var getImagesFromSelector = function getImagesFromSelector(selector) {
      try {
        if (Array.isArray(selector)) {
          return selector.filter(isSupported);
        }
        if (isNodeList(selector)) {
          return [].slice.call(selector).filter(isSupported);
        }
        if (isNode(selector)) {
          return [ selector ].filter(isSupported);
        }
        if (typeof selector === "string") {
          return [].slice.call(document.querySelectorAll(selector)).filter(isSupported);
        }
        return [];
      } catch (err) {
        throw new TypeError("The provided selector is invalid.\n" + "Expects a CSS selector, a Node element, a NodeList or an array.\n" + "See: https://github.com/francoischalifour/medium-zoom");
      }
    };
    var createOverlay = function createOverlay(background) {
      var overlay = document.createElement("div");
      overlay.classList.add("medium-zoom-overlay");
      overlay.style.background = background;
      return overlay;
    };
    var cloneTarget = function cloneTarget(template) {
      var _template$getBounding = template.getBoundingClientRect(), top = _template$getBounding.top, left = _template$getBounding.left, width = _template$getBounding.width, height = _template$getBounding.height;
      var clone = template.cloneNode();
      var scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
      var scrollLeft = window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0;
      clone.removeAttribute("id");
      clone.style.position = "absolute";
      clone.style.top = top + scrollTop + "px";
      clone.style.left = left + scrollLeft + "px";
      clone.style.width = width + "px";
      clone.style.height = height + "px";
      clone.style.transform = "";
      return clone;
    };
    var createCustomEvent = function createCustomEvent(type, params) {
      var eventParams = _extends({
        bubbles: false,
        cancelable: false,
        detail: undefined
      }, params);
      if (typeof window.CustomEvent === "function") {
        return new CustomEvent(type, eventParams);
      }
      var customEvent = document.createEvent("CustomEvent");
      customEvent.initCustomEvent(type, eventParams.bubbles, eventParams.cancelable, eventParams.detail);
      return customEvent;
    };
    var mediumZoom = function mediumZoom(selector) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var Promise = window.Promise || function Promise(fn) {
        function noop() {}
        fn(noop, noop);
      };
      var _handleClick = function _handleClick(event) {
        var target = event.target;
        if (target === overlay) {
          close();
          return;
        }
        if (images.indexOf(target) === -1) {
          return;
        }
        toggle({
          target: target
        });
      };
      var _handleScroll = function _handleScroll() {
        if (isAnimating || !active.original) {
          return;
        }
        var currentScroll = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
        if (Math.abs(scrollTop - currentScroll) > zoomOptions.scrollOffset) {
          setTimeout(close, 150);
        }
      };
      var _handleKeyUp = function _handleKeyUp(event) {
        var key = event.key || event.keyCode;
        if (key === "Escape" || key === "Esc" || key === 27) {
          close();
        }
      };
      var update = function update() {
        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        var newOptions = options;
        if (options.background) {
          overlay.style.background = options.background;
        }
        if (options.container && options.container instanceof Object) {
          newOptions.container = _extends({}, zoomOptions.container, options.container);
        }
        if (options.template) {
          var template = isNode(options.template) ? options.template : document.querySelector(options.template);
          newOptions.template = template;
        }
        zoomOptions = _extends({}, zoomOptions, newOptions);
        images.forEach(function(image) {
          image.dispatchEvent(createCustomEvent("medium-zoom:update", {
            detail: {
              zoom: zoom
            }
          }));
        });
        return zoom;
      };
      var clone = function clone() {
        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        return mediumZoom(_extends({}, zoomOptions, options));
      };
      var attach = function attach() {
        for (var _len = arguments.length, selectors = Array(_len), _key = 0; _key < _len; _key++) {
          selectors[_key] = arguments[_key];
        }
        var newImages = selectors.reduce(function(imagesAccumulator, currentSelector) {
          return [].concat(imagesAccumulator, getImagesFromSelector(currentSelector));
        }, []);
        newImages.filter(function(newImage) {
          return images.indexOf(newImage) === -1;
        }).forEach(function(newImage) {
          images.push(newImage);
          newImage.classList.add("medium-zoom-image");
        });
        eventListeners.forEach(function(_ref) {
          var type = _ref.type, listener = _ref.listener, options = _ref.options;
          newImages.forEach(function(image) {
            image.addEventListener(type, listener, options);
          });
        });
        return zoom;
      };
      var detach = function detach() {
        for (var _len2 = arguments.length, selectors = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          selectors[_key2] = arguments[_key2];
        }
        if (active.zoomed) {
          close();
        }
        var imagesToDetach = selectors.length > 0 ? selectors.reduce(function(imagesAccumulator, currentSelector) {
          return [].concat(imagesAccumulator, getImagesFromSelector(currentSelector));
        }, []) : images;
        imagesToDetach.forEach(function(image) {
          image.classList.remove("medium-zoom-image");
          image.dispatchEvent(createCustomEvent("medium-zoom:detach", {
            detail: {
              zoom: zoom
            }
          }));
        });
        images = images.filter(function(image) {
          return imagesToDetach.indexOf(image) === -1;
        });
        return zoom;
      };
      var on = function on(type, listener) {
        var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
        images.forEach(function(image) {
          image.addEventListener("medium-zoom:" + type, listener, options);
        });
        eventListeners.push({
          type: "medium-zoom:" + type,
          listener: listener,
          options: options
        });
        return zoom;
      };
      var off = function off(type, listener) {
        var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
        images.forEach(function(image) {
          image.removeEventListener("medium-zoom:" + type, listener, options);
        });
        eventListeners = eventListeners.filter(function(eventListener) {
          return !(eventListener.type === "medium-zoom:" + type && eventListener.listener.toString() === listener.toString());
        });
        return zoom;
      };
      var open = function open() {
        var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, target = _ref2.target;
        var _animate = function _animate() {
          var container = {
            width: document.documentElement.clientWidth,
            height: document.documentElement.clientHeight,
            left: 0,
            top: 0,
            right: 0,
            bottom: 0
          };
          var viewportWidth = void 0;
          var viewportHeight = void 0;
          if (zoomOptions.container) {
            if (zoomOptions.container instanceof Object) {
              container = _extends({}, container, zoomOptions.container);
              viewportWidth = container.width - container.left - container.right - zoomOptions.margin * 2;
              viewportHeight = container.height - container.top - container.bottom - zoomOptions.margin * 2;
            } else {
              var zoomContainer = isNode(zoomOptions.container) ? zoomOptions.container : document.querySelector(zoomOptions.container);
              var _zoomContainer$getBou = zoomContainer.getBoundingClientRect(), _width = _zoomContainer$getBou.width, _height = _zoomContainer$getBou.height, _left = _zoomContainer$getBou.left, _top = _zoomContainer$getBou.top;
              container = _extends({}, container, {
                width: _width,
                height: _height,
                left: _left,
                top: _top
              });
            }
          }
          viewportWidth = viewportWidth || container.width - zoomOptions.margin * 2;
          viewportHeight = viewportHeight || container.height - zoomOptions.margin * 2;
          var zoomTarget = active.zoomedHd || active.original;
          var naturalWidth = isSvg(zoomTarget) ? viewportWidth : zoomTarget.naturalWidth || viewportWidth;
          var naturalHeight = isSvg(zoomTarget) ? viewportHeight : zoomTarget.naturalHeight || viewportHeight;
          var _zoomTarget$getBoundi = zoomTarget.getBoundingClientRect(), top = _zoomTarget$getBoundi.top, left = _zoomTarget$getBoundi.left, width = _zoomTarget$getBoundi.width, height = _zoomTarget$getBoundi.height;
          var scaleX = Math.min(naturalWidth, viewportWidth) / width;
          var scaleY = Math.min(naturalHeight, viewportHeight) / height;
          var scale = Math.min(scaleX, scaleY);
          var translateX = (-left + (viewportWidth - width) / 2 + zoomOptions.margin + container.left) / scale;
          var translateY = (-top + (viewportHeight - height) / 2 + zoomOptions.margin + container.top) / scale;
          var transform = "scale(" + scale + ") translate3d(" + translateX + "px, " + translateY + "px, 0)";
          active.zoomed.style.transform = transform;
          if (active.zoomedHd) {
            active.zoomedHd.style.transform = transform;
          }
        };
        return new Promise(function(resolve) {
          if (target && images.indexOf(target) === -1) {
            resolve(zoom);
            return;
          }
          var _handleOpenEnd = function _handleOpenEnd() {
            isAnimating = false;
            active.zoomed.removeEventListener("transitionend", _handleOpenEnd);
            active.original.dispatchEvent(createCustomEvent("medium-zoom:opened", {
              detail: {
                zoom: zoom
              }
            }));
            resolve(zoom);
          };
          if (active.zoomed) {
            resolve(zoom);
            return;
          }
          if (target) {
            active.original = target;
          } else if (images.length > 0) {
            var _images = images;
            active.original = _images[0];
          } else {
            resolve(zoom);
            return;
          }
          active.original.dispatchEvent(createCustomEvent("medium-zoom:open", {
            detail: {
              zoom: zoom
            }
          }));
          scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
          isAnimating = true;
          active.zoomed = cloneTarget(active.original);
          document.body.appendChild(overlay);
          if (zoomOptions.template) {
            var template = isNode(zoomOptions.template) ? zoomOptions.template : document.querySelector(zoomOptions.template);
            active.template = document.createElement("div");
            active.template.appendChild(template.content.cloneNode(true));
            document.body.appendChild(active.template);
          }
          document.body.appendChild(active.zoomed);
          window.requestAnimationFrame(function() {
            document.body.classList.add("medium-zoom--opened");
          });
          active.original.classList.add("medium-zoom-image--hidden");
          active.zoomed.classList.add("medium-zoom-image--opened");
          active.zoomed.addEventListener("click", close);
          active.zoomed.addEventListener("transitionend", _handleOpenEnd);
          if (active.original.getAttribute("data-zoom-src")) {
            active.zoomedHd = active.zoomed.cloneNode();
            active.zoomedHd.removeAttribute("srcset");
            active.zoomedHd.removeAttribute("sizes");
            active.zoomedHd.src = active.zoomed.getAttribute("data-zoom-src");
            active.zoomedHd.onerror = function() {
              clearInterval(getZoomTargetSize);
              console.warn("Unable to reach the zoom image target " + active.zoomedHd.src);
              active.zoomedHd = null;
              _animate();
            };
            var getZoomTargetSize = setInterval(function() {
              if (active.zoomedHd.complete) {
                clearInterval(getZoomTargetSize);
                active.zoomedHd.classList.add("medium-zoom-image--opened");
                active.zoomedHd.addEventListener("click", close);
                document.body.appendChild(active.zoomedHd);
                _animate();
              }
            }, 10);
          } else if (active.original.hasAttribute("srcset")) {
            active.zoomedHd = active.zoomed.cloneNode();
            active.zoomedHd.removeAttribute("sizes");
            var loadEventListener = active.zoomedHd.addEventListener("load", function() {
              active.zoomedHd.removeEventListener("load", loadEventListener);
              active.zoomedHd.classList.add("medium-zoom-image--opened");
              active.zoomedHd.addEventListener("click", close);
              document.body.appendChild(active.zoomedHd);
              _animate();
            });
          } else {
            _animate();
          }
        });
      };
      var close = function close() {
        return new Promise(function(resolve) {
          if (isAnimating || !active.original) {
            resolve(zoom);
            return;
          }
          var _handleCloseEnd = function _handleCloseEnd() {
            active.original.classList.remove("medium-zoom-image--hidden");
            document.body.removeChild(active.zoomed);
            if (active.zoomedHd) {
              document.body.removeChild(active.zoomedHd);
            }
            document.body.removeChild(overlay);
            active.zoomed.classList.remove("medium-zoom-image--opened");
            if (active.template) {
              document.body.removeChild(active.template);
            }
            isAnimating = false;
            active.zoomed.removeEventListener("transitionend", _handleCloseEnd);
            active.original.dispatchEvent(createCustomEvent("medium-zoom:closed", {
              detail: {
                zoom: zoom
              }
            }));
            active.original = null;
            active.zoomed = null;
            active.zoomedHd = null;
            active.template = null;
            resolve(zoom);
          };
          isAnimating = true;
          document.body.classList.remove("medium-zoom--opened");
          active.zoomed.style.transform = "";
          if (active.zoomedHd) {
            active.zoomedHd.style.transform = "";
          }
          if (active.template) {
            active.template.style.transition = "opacity 150ms";
            active.template.style.opacity = 0;
          }
          active.original.dispatchEvent(createCustomEvent("medium-zoom:close", {
            detail: {
              zoom: zoom
            }
          }));
          active.zoomed.addEventListener("transitionend", _handleCloseEnd);
        });
      };
      var toggle = function toggle() {
        var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, target = _ref3.target;
        if (active.original) {
          return close();
        }
        return open({
          target: target
        });
      };
      var getOptions = function getOptions() {
        return zoomOptions;
      };
      var getImages = function getImages() {
        return images;
      };
      var getZoomedImage = function getZoomedImage() {
        return active.original;
      };
      var images = [];
      var eventListeners = [];
      var isAnimating = false;
      var scrollTop = 0;
      var zoomOptions = options;
      var active = {
        original: null,
        zoomed: null,
        zoomedHd: null,
        template: null
      };
      if (Object.prototype.toString.call(selector) === "[object Object]") {
        zoomOptions = selector;
      } else if (selector || typeof selector === "string") {
        attach(selector);
      }
      zoomOptions = _extends({
        margin: 0,
        background: "#fff",
        scrollOffset: 40,
        container: null,
        template: null
      }, zoomOptions);
      var overlay = createOverlay(zoomOptions.background);
      document.addEventListener("click", _handleClick);
      document.addEventListener("keyup", _handleKeyUp);
      document.addEventListener("scroll", _handleScroll);
      window.addEventListener("resize", close);
      var zoom = {
        open: open,
        close: close,
        toggle: toggle,
        update: update,
        clone: clone,
        attach: attach,
        detach: detach,
        on: on,
        off: off,
        getOptions: getOptions,
        getImages: getImages,
        getZoomedImage: getZoomedImage
      };
      return zoom;
    };
    return mediumZoom;
  });

mediumZoom(document.querySelectorAll('div.post-content img'), {
    background: '#fff'
});

 layouts/partials/footer.html

@@ -1,8 +1,14 @@

</body>
<script type="text/javascript" src="{{ `js/jquery.min.js` | absURL }}"></script>
<script type="text/javascript" src="{{ `js/jquery-migrate.min.js` | absURL }}"></script>
<script type="text/javascript" src="{{ `js/jquery-appear.min.js` | absURL }}"></script>

{{ $js := resources.Get "js/jquery.js" }}
{{ $secureJS := $js |  resources.Minify | resources.Fingerprint }}
<script type="text/javascript" src="{{ $secureJS.Permalink }}" integrity="{{ $secureJS.Data.Integrity }}"></script>
{{ $migrate := resources.Get "js/jquery-migrate.js" }}
{{ $appear := resources.Get "js/jquery-appear.js" }}
{{ $js := slice $migrate $appear | resources.Concat "js/bundle.js" }}
{{ $secureJS := $js |  resources.Minify | resources.Fingerprint }}
<script type="text/javascript" src="{{ $secureJS.Permalink }}" integrity="{{ $secureJS.Data.Integrity }}"></script>
{{- partial "medium-zoom.html" . -}}
{{- partial "math.html" . -}}
{{- template "_internal/google_analytics_async.html" . -}}

 layouts/partials/head.html

@@ -4,7 +4,8 @@
    {{- hugo.Generator -}}
    <meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
    <meta name="description" content="{{ .Site.Params.description }}">
    <link rel="stylesheet" href="{{ `css/style.css` | absURL }}" type="text/css">
    {{ $style := resources.Get "css/style.css" | resources.Minify | resources.Fingerprint }}
    <link rel="stylesheet" href="{{ $style.Permalink }}" integrity="{{ $style.Data.Integrity }}" type="text/css">
    {{ range .Site.Params.customCss -}}
    <link rel="stylesheet" href="{{ . | absURL }}" type="text/css">
    {{- end }}

 layouts/partials/medium-zoom.html

@@ -1,7 +1,5 @@
<script type="text/javascript" src="{{ `js/medium-zoom.min.js` | absURL }}"></script>
<script>
    mediumZoom(document.querySelectorAll('div.post-content img'), {
        background: '#fff'
    });
</script>
<link rel="stylesheet" href="{{ `css/medium-zoom.css` | absURL }}" type="text/css">
{{ $js := resources.Get "js/medium-zoom.js" }}
{{ $secureJS := $js |  resources.Minify | resources.Fingerprint }}
<script type="text/javascript" src="{{ $secureJS.Permalink }}" integrity="{{ $secureJS.Data.Integrity }}"></script>
{{ $style := resources.Get "css/medium-zoom.css" | resources.Minify | resources.Fingerprint }}
<link rel="stylesheet" href="{{ $style.Permalink }}" integrity="{{ $style.Data.Integrity }}" type="text/css">

 static/js/jquery-appear.min.js

File was deleted

 static/js/jquery-migrate.min.js

File was deleted

 static/js/jquery.min.js

File was deleted

 static/js/medium-zoom.min.js

File was deleted