RubyGems - j1m_scroll - Versions diffs - 0.0.1 - Mend

j1m_scroll 0.0.1

Files changed (101) hide show

data/assets/themes/j1/iframe_resizer/example/index.html ADDED Viewed

@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8">
+		<title>iFrame message passing test</title>
+		<meta name="description" content="iFrame message passing test">
+		<meta name="viewport" content="width=device-width">
+		<meta http-equiv="X-UA-Compatible" content="IE=edge">
+	</head>
+	<body>
+		<h2>Automagically resizing iFrame</h2>
+		<p>Resize window or click one of the links in the iFrame to watch it resize. Or try with <a name="anchorParentTest" href="two.html">two iFrames</a>.</p>
+		<div style="margin:20px;">
+			<iframe src="frame.content.html" width="100%" scrolling="no"></iframe>
+		</div>
+		<p id="callback">
+		</p>
+		<div style="margin: 8px 0;font-size:13px;">
+			For details on how this works, see
+			<a href="http://davidjbradshaw.github.io/iframe-resizer/">http://davidjbradshaw.github.io/iframe-resizer/</a>.
+		</div>
+		<!-- MDN PolyFils for IE8 (This is not normally needed if you use the jQuery version) -->
+		<!--[if lte IE 8]>
+			<script type="text/javascript" src="../js/ie8.polyfils.min.js"></script>
+		<![endif]-->
+		<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
+		<script type="text/javascript" src="../js/iframeResizer.min.js"></script>
+		<script type="text/javascript">
+			/*
+			 * If you do not understand what the code below does, then please just use the
+			 * following call in your own code.
+			 *
+			 *   iFrameResize({log:true});
+			 *
+			 * Once you have it working, set the log option to false.
+			 */
+			iFrameResize({
+				log                     : true,                  // Enable console logging
+				inPageLinks             : true,
+				resizedCallback         : function(messageData){ // Callback fn when resize is received
+					$('p#callback').html(
+						'<b>Frame ID:</b> '    + messageData.iframe.id +
+						' <b>Height:</b> '     + messageData.height +
+						' <b>Width:</b> '      + messageData.width +
+						' <b>Event type:</b> ' + messageData.type
+					);
+				},
+				messageCallback         : function(messageData){ // Callback fn when message is received
+					$('p#callback').html(
+						'<b>Frame ID:</b> '    + messageData.iframe.id +
+						' <b>Message:</b> '    + messageData.message
+					);
+					alert(messageData.message);
+					document.getElementsByTagName('iframe')[0].iFrameResizer.sendMessage('Hello back from parent page');
+				},
+				closedCallback         : function(id){ // Callback fn when iFrame is closed
+					$('p#callback').html(
+						'<b>IFrame (</b>'    + id +
+						'<b>) removed from page.</b>'
+					);
+				}
+			});
+		</script>
+	</body>
+</html>

data/assets/themes/j1/iframe_resizer/example/two.html ADDED Viewed

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8">
+		<title>iFrame message passing test</title>
+		<meta name="description" content="iFrame message passing test">
+		<meta name="viewport" content="width=device-width">
+		<meta http-equiv="X-UA-Compatible" content="IE=edge">
+	</head>
+	<body>
+		<h2>Automagically resizing iFrame</h2>
+		<p>Resize window or click one of the links in the iFrame to watch it resize. Or go back to a <a name="anchorParentTest" href="index.html">single iFrame</a>.</p>
+		<div style="margin:20px;">
+			<iframe src="frame.content.html" width="48%" scrolling="no" style="float:left;margin-right:2%"></iframe>
+			<iframe src="frame.content.html" width="48%" scrolling="no"></iframe>
+		</div>
+		<p id="callback">
+		</p>
+		<div style="margin: 8px 0;font-size:13px;">
+			For details on how this works, see
+			<a href="http://davidjbradshaw.github.io/iframe-resizer/">http://davidjbradshaw.github.io/iframe-resizer/</a>.
+		</div>
+		<!-- MDN PolyFils for IE8 -->
+		<!--[if lte IE 8]>
+			<script type="text/javascript" src="../js/ie8.polyfils.min.js"></script>
+		<![endif]-->
+		<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
+		<script type="text/javascript" src="../src/iframeResizer.js"></script>
+		<script type="text/javascript">
+			/*
+			 * If you do not understand what the code below does, then please just use the
+			 * following call in your own code.
+			 *
+			 *   iFrameResize({log:true});
+			 *
+			 * Once you have it working, set the log option to false.
+			 */
+			iFrameResize({
+				log                     : true,                  // Enable console logging
+				enablePublicMethods     : true,                  // Enable methods within iframe hosted page
+				enableInPageLinks       : true,
+				resizedCallback         : function(messageData){ // Callback fn when resize is received
+					$('p#callback').html(
+						'<b>Frame ID:</b> '    + messageData.iframe.id +
+						' <b>Height:</b> '     + messageData.height +
+						' <b>Width:</b> '      + messageData.width +
+						' <b>Event type:</b> ' + messageData.type
+					);
+				},
+				messageCallback         : function(messageData){ // Callback fn when message is received
+					$('p#callback').html(
+						'<b>Frame ID:</b> '    + messageData.iframe.id +
+						' <b>Message:</b> '    + messageData.message
+					);
+					alert(messageData.message + ' (' + messageData.iframe.id + ')' );
+				},
+				closedCallback         : function(id){ // Callback fn when iFrame is closed
+					$('p#callback').html(
+						'<b>IFrame (</b>'    + id +
+						'<b>) removed from page.</b>'
+					);
+				}
+			});
+		</script>
+	</body>
+</html>

data/assets/themes/j1/iframe_resizer/gruntfile.js ADDED Viewed

@@ -0,0 +1,215 @@
+/*global module:false*/
+module.exports = function(grunt) {
+  'Use strict';
+  // show elapsed time at the end
+  require('time-grunt')(grunt);
+  // load all grunt tasks
+  //require('load-grunt-tasks')(grunt);
+  require('jit-grunt')(grunt,{
+    'bump-only':'grunt-bump',
+    'bump-commit':'grunt-bump',
+    'coveralls':'grunt-karma-coveralls'
+  });
+  // Project configuration.
+  grunt.initConfig({
+    pkg: grunt.file.readJSON('package.json'),
+    meta: {
+      bannerLocal: '/*! iFrame Resizer (iframeSizer.min.js ) - v<%= pkg.version %> - ' +
+        '<%= grunt.template.today("yyyy-mm-dd") %>\n' +
+        ' *  Desc: Force cross domain iframes to size to content.\n' +
+        ' *  Requires: iframeResizer.contentWindow.min.js to be loaded into the target frame.\n' +
+        ' *  Copyright: (c) <%= grunt.template.today("yyyy") %> David J. Bradshaw - dave@bradshaw.net\n' +
+        ' *  License: MIT\n */\n',
+      bannerRemote: '/*! iFrame Resizer (iframeSizer.contentWindow.min.js) - v<%= pkg.version %> - ' +
+        '<%= grunt.template.today("yyyy-mm-dd") %>\n' +
+        ' *  Desc: Include this file in any page being loaded into an iframe\n' +
+        ' *        to force the iframe to resize to the content size.\n' +
+        ' *  Requires: iframeResizer.min.js on host page.\n' +
+        ' *  Copyright: (c) <%= grunt.template.today("yyyy") %> David J. Bradshaw - dave@bradshaw.net\n' +
+        ' *  License: MIT\n */\n'
+    },
+    clean: ['coverage', 'coverageLcov'],
+    qunit: {
+      files: ['test/*.html']
+    },
+    karma: {
+      options: {
+        configFile: 'karma.conf.js'
+      },
+      travis:{
+        singleRun: true,
+        browsers: ['PhantomJS'],
+        coverageReporter: {
+          type : 'lcov',
+          dir : 'coverageLcov/'
+        },
+      },
+      single:{
+        singleRun: true,
+        browsers: ['Chrome', 'Firefox',  'PhantomJS'] // 'Safari' ,
+      }
+    },
+    coveralls: {
+      options: {
+          debug: true,
+          coverageDir: 'coverageLcov',
+          dryRun: false,
+          force: true,
+          recursive: true
+      }
+    },
+    jshint: {
+      options: {
+          globals: {
+          jQuery:false,
+          require:true,
+          process:true
+        },
+      },
+      gruntfile: {
+        src: 'gruntfile.js'
+      },
+      code: {
+        src: 'src/**/*.js'
+      },
+    },
+    uglify: {
+      options: {
+        sourceMap:true,
+        sourceMapIncludeSources:true,
+        report:'gzip',
+      },
+      local: {
+        options:{
+          banner:'<%= meta.bannerLocal %>',
+          sourceMapName: 'js/iframeResizer.map'
+        },
+        src: ['js/iframeResizer.js'],
+        dest: 'js/iframeResizer.min.js',
+      },
+      remote: {
+        options: {
+          banner:'<%= meta.bannerRemote %>',
+          sourceMapName: 'js/iframeResizer.contentWindow.map'
+        },
+        src: ['js/iframeResizer.contentWindow.js'],
+        dest: 'js/iframeResizer.contentWindow.min.js',
+      },
+      polyfil: {
+        options: {
+          banner:'// IE8 polyfils for iframeResizer.js\n',
+          sourceMapName: 'js/ie8.polyfils.map'
+        },
+        src: ['src/ie8.polyfils.js'],
+        dest: 'js/ie8.polyfils.min.js',
+      }
+    },
+    watch: {
+      files: ['src/**/*'],
+      tasks: 'default'
+    },
+    bump: {
+      options: {
+        files: ['package.json','bower.json','iframeResizer.jquery.json'],
+        updateConfigs: ['pkg'],
+        commit: true,
+        commitMessage: 'Release v%VERSION%',
+        commitFiles: ['-a'], // '-a' for all files
+        createTag: true,
+        tagName: 'v%VERSION%',
+        tagMessage: 'Version %VERSION%',
+        push: true,
+        pushTo: 'origin',
+        gitDescribeOptions: '--tags --always --abbrev=1 --dirty=-d' // options to use with '$ git describe'
+      }
+    },
+    shell: {
+      options:{
+        stdout: true,
+        stderr: true,
+        failOnError: true
+      },
+      npm:{
+        command: 'npm publish'
+      },
+      deployExample: {
+        command: function(){
+          var
+            retStr = '',
+            fs = require('fs');
+          if (fs.existsSync('bin')) {
+              retStr = 'bin/deploy.sh';
+          }
+          return retStr;
+        }
+      }
+    },
+    jsonlint: {
+      json: {
+        src: [ '*.json' ]
+      }
+    },
+   removeBlock: {
+      options : ["TEST CODE START", 'TEST CODE END'],
+      files : [
+        {src : 'src/iframeResizer.contentWindow.js', dest : 'js/iframeResizer.contentWindow.js'}
+      ]
+    },
+    copy: {
+      main: {
+        nonull: true,
+        src: 'src/iframeResizer.js',
+        dest: 'js/iframeResizer.js',
+      },
+    },
+  });
+  grunt.registerTask('default', ['notest','karma:single']);
+  grunt.registerTask('build',   ['removeBlock','copy','uglify']);
+  grunt.registerTask('notest',  ['jsonlint','jshint','build']);
+  grunt.registerTask('test',    ['clean','jshint','qunit','karma:single']);
+  grunt.registerTask('travis',  ['clean','notest','qunit','karma:travis','coveralls']);
+  grunt.registerTask('postBump',['build','bump-commit','shell']);
+  grunt.registerTask('preBump', ['clean','notest','qunit']);
+  grunt.registerTask('patch',   ['preBump','bump-only:patch','postBump']);
+  grunt.registerTask('minor',   ['preBump','bump-only:minor','postBump']);
+  grunt.registerTask('major',   ['preBump','bump-only:major','postBump']);
+  grunt.registerMultiTask('removeBlock', function() {
+    // set up a removal regular expression
+    var removalRegEx = new RegExp('(\/\/ ' + this.options()[0] + ' \/\/)(?:[^])*?(\/\/ ' + this.options()[1] +  ' \/\/)', 'g');
+    this.data.forEach(function(fileObj){
+      var sourceFile = grunt.file.read( fileObj.src ),
+          removedFile = sourceFile.replace( removalRegEx, '' ),
+          targetFile = grunt.file.write( fileObj.dest, removedFile );
+    });// for each loop end
+  });
+};

data/assets/themes/j1/iframe_resizer/iframeResizer.jquery.json ADDED Viewed

@@ -0,0 +1,41 @@
+{
+	"name": "iframeResizer",
+	"title": "Iframe Resizer",
+	"description": "Responsively keep same and cross domain iFrames sized to their content with support for window/content resizing, multiple and nested iFrames. (Works with IE8+)",
+	"keywords": [
+		"Cross-Domain",
+		"iFrame",
+		"Resizing",
+		"Resizer",
+		"postMessage",
+		"content",
+		"height",
+		"autoheight",
+		"auto-height",
+		"width",
+		"mutationObserver",
+		"RWD",
+		"responsive"
+	],
+	"version": "3.5.5",
+	"author": {
+		"name": "David J. Bradshaw",
+		"email": "davidjbradshaw+github@gmail.com"
+	},
+	"maintainers": [{
+		"name": "David J. Bradshaw",
+		"email": "davidjbradshaw+github@gmail.com"
+	}
+	],
+	"licenses": [{
+		"type": "MIT",
+		"url": "https://github.com/jquery/jquery-color/blob/2.1.2/MIT-LICENSE.txt"
+	}
+	],
+	"bugs": "https://github.com/davidjbradshaw/iframe-resizer/issues",
+	"homepage": "http://davidjbradshaw.github.io/iframe-resizer/",
+	"docs": "https://github.com/davidjbradshaw/iframe-resizer",
+	"dependencies": {
+	"jquery": ">=1.0"
+	}
+}

data/assets/themes/j1/iframe_resizer/index.js ADDED Viewed

@@ -0,0 +1,4 @@
+'use strict';
+module.exports = require('./js');

data/assets/themes/j1/iframe_resizer/js/_client.js ADDED Viewed

@@ -0,0 +1,1131 @@
+/*
+ # -----------------------------------------------------------------------------
+ #  J1: ~/assets/themes/j1/application-manager/js/client.js
+ #  Modified JavaScript based on iframeResizer version 3.5.5.
+ #
+ #  J1 Application Manager allows to include dynamic HTML pages, applications
+ #  sites using iframes for J1. The client component needs to be placed in the
+ #  page/application that should be contained within the iFrame. This file is
+ #  designed to be a guest/client on someone else's system. The client has no
+ #  dependencies and won't do anything until it's activated by a message from
+ #  the containing page.
+ #
+ #  Product/Info:
+ #  http://jekyll.one
+ #  https://github.com/davidjbradshaw/iframe-resizer
+ #
+ #  Copyright (C) 2013-2016 David J. Bradshaw
+ #  Copyright (C) 2016 Juergen Adams
+ #
+ #  iframeResizer: Licensed under Open Source Iniative MIT.
+ #  For details, see http://opensource.org/licenses/MIT
+ #  J1: Licensed under the Creative Commons Attribution 3.0 Unported License.
+ #  For details, see http://creativecommons.org/licenses/by/3.0/.
+ #
+ # -----------------------------------------------------------------------------
+ #  Note: Include this file in any page being loaded into an iframe
+ #  to force the iframe to resize to the content size.
+ #
+ # -----------------------------------------------------------------------------
+ #  $LastChangedDate: 2016-12-04 19:37:21 +0100 (So, 04 Dez 2016) $
+ #  $LastChangedRevision: 13 $
+ #  $LastChangedBy: jadams $
+ # -----------------------------------------------------------------------------
+*/
+;(function(window, undefined) {
+	'use strict';
+	var
+		autoResize            = true,
+		base                  = 10,
+		bodyBackground        = '',
+		bodyMargin            = 0,
+		bodyMarginStr         = '',
+		bodyObserver          = null,
+		bodyPadding           = '',
+		calculateWidth        = false,
+		doubleEventList       = {'resize':1,'click':1},
+		eventCancelTimer      = 128,
+		firstRun              = true,
+		height                = 1,
+		heightCalcModeDefault = 'bodyOffset',
+		heightCalcMode        = heightCalcModeDefault,
+		initLock              = true,
+		initMsg               = '',
+		inPageLinks           = {},
+		interval              = 32,
+		intervalTimer         = null,
+		logging               = false,
+		msgID                 = '[iFrameSizer]',  //Must match host page msg ID
+		msgIdLen              = msgID.length,
+		myID                  = '',
+		observer              = null,
+		resetRequiredMethods  = {max:1,min:1,bodyScroll:1,documentElementScroll:1},
+		resizeFrom            = 'child',
+		sendPermit            = true,
+		target                = window.parent,
+		targetOriginDefault   = '*',
+		tolerance             = 0,
+		triggerLocked         = false,
+		triggerLockedTimer    = null,
+		throttledTimer        = 16,
+		width                 = 1,
+		widthCalcModeDefault  = 'scroll',
+		widthCalcMode         = widthCalcModeDefault,
+		win                   = window,
+		messageCallback       = function(){ warn('MessageCallback function not defined'); },
+		readyCallback         = function(){},
+		pageInfoCallback      = function(){},
+		customCalcMethods     = {
+			height: function(){
+				warn('Custom height calculation function not defined');
+				return document.documentElement.offsetHeight;
+			},
+			width: function(){
+				warn('Custom width calculation function not defined');
+				return document.body.scrollWidth;
+			}
+		};
+	function addEventListener(el,evt,func){
+		/* istanbul ignore else */ // Not testable in phantonJS
+		if ('addEventListener' in window){
+			el.addEventListener(evt,func, false);
+		} else if ('attachEvent' in window){ //IE
+			el.attachEvent('on'+evt,func);
+		}
+	}
+	function removeEventListener(el,evt,func){
+		/* istanbul ignore else */ // Not testable in phantonJS
+		if ('removeEventListener' in window){
+			el.removeEventListener(evt,func, false);
+		} else if ('detachEvent' in window){ //IE
+			el.detachEvent('on'+evt,func);
+		}
+	}
+	function capitalizeFirstLetter(string) {
+		return string.charAt(0).toUpperCase() + string.slice(1);
+	}
+	//Based on underscore.js
+	function throttle(func) {
+		var
+			context, args, result,
+			timeout = null,
+			previous = 0,
+			later = function() {
+				previous = getNow();
+				timeout = null;
+				result = func.apply(context, args);
+				if (!timeout) {
+					context = args = null;
+				}
+			};
+		return function() {
+			var now = getNow();
+			if (!previous) {
+				previous = now;
+			}
+			var remaining = throttledTimer - (now - previous);
+			context = this;
+			args = arguments;
+			if (remaining <= 0 || remaining > throttledTimer) {
+				if (timeout) {
+					clearTimeout(timeout);
+					timeout = null;
+				}
+				previous = now;
+				result = func.apply(context, args);
+				if (!timeout) {
+					context = args = null;
+				}
+			} else if (!timeout) {
+				timeout = setTimeout(later, remaining);
+			}
+			return result;
+		};
+	}
+	var getNow = Date.now || function() {
+		/* istanbul ignore next */ // Not testable in PhantonJS
+		return new Date().getTime();
+	};
+	function formatLogMsg(msg){
+		return msgID + '[' + myID + ']' + ' ' + msg;
+	}
+	function log(msg){
+		if (logging && ('object' === typeof window.console)){
+			console.log(formatLogMsg(msg));
+		}
+	}
+	function warn(msg){
+		if ('object' === typeof window.console){
+			console.warn(formatLogMsg(msg));
+		}
+	}
+	function init(){
+		readDataFromParent();
+		log('Initialising iFrame ('+location.href+')');
+		readDataFromPage();
+		setMargin();
+		setBodyStyle('background',bodyBackground);
+		setBodyStyle('padding',bodyPadding);
+		injectClearFixIntoBodyElement();
+		checkHeightMode();
+		checkWidthMode();
+		stopInfiniteResizingOfIFrame();
+		setupPublicMethods();
+		startEventListeners();
+		inPageLinks = setupInPageLinks();
+		sendSize('init','Init message from host page');
+		readyCallback();
+	}
+	function readDataFromParent(){
+		function strBool(str){
+			return 'true' === str ? true : false;
+		}
+		var data = initMsg.substr(msgIdLen).split(':');
+		myID               = data[0];
+		bodyMargin         = (undefined !== data[1]) ? Number(data[1])   : bodyMargin; //For V1 compatibility
+		calculateWidth     = (undefined !== data[2]) ? strBool(data[2])  : calculateWidth;
+		logging            = (undefined !== data[3]) ? strBool(data[3])  : logging;
+		interval           = (undefined !== data[4]) ? Number(data[4])   : interval;
+		autoResize         = (undefined !== data[6]) ? strBool(data[6])  : autoResize;
+		bodyMarginStr      = data[7];
+		heightCalcMode     = (undefined !== data[8]) ? data[8]           : heightCalcMode;
+		bodyBackground     = data[9];
+		bodyPadding        = data[10];
+		tolerance          = (undefined !== data[11]) ? Number(data[11]) : tolerance;
+		inPageLinks.enable = (undefined !== data[12]) ? strBool(data[12]): false;
+		resizeFrom         = (undefined !== data[13]) ? data[13]         : resizeFrom;
+		widthCalcMode      = (undefined !== data[14]) ? data[14]         : widthCalcMode;
+	}
+	function readDataFromPage(){
+		function readData(){
+			var data = window.iFrameResizer;
+			log('Reading data from page: ' + JSON.stringify(data));
+			messageCallback     = ('messageCallback'         in data) ? data.messageCallback         : messageCallback;
+			readyCallback       = ('readyCallback'           in data) ? data.readyCallback           : readyCallback;
+			targetOriginDefault = ('targetOrigin'            in data) ? data.targetOrigin            : targetOriginDefault;
+			heightCalcMode      = ('heightCalculationMethod' in data) ? data.heightCalculationMethod : heightCalcMode;
+			widthCalcMode       = ('widthCalculationMethod'  in data) ? data.widthCalculationMethod  : widthCalcMode;
+		}
+		function setupCustomCalcMethods(calcMode, calcFunc){
+			if ('function' === typeof calcMode) {
+				log('Setup custom ' + calcFunc + 'CalcMethod');
+				customCalcMethods[calcFunc] = calcMode;
+				calcMode = 'custom';
+			}
+			return calcMode;
+		}
+		if(('iFrameResizer' in window) && (Object === window.iFrameResizer.constructor)) {
+			readData();
+			heightCalcMode = setupCustomCalcMethods(heightCalcMode, 'height');
+			widthCalcMode  = setupCustomCalcMethods(widthCalcMode,  'width');
+		}
+		log('TargetOrigin for parent set to: ' + targetOriginDefault);
+	}
+	function chkCSS(attr,value){
+		if (-1 !== value.indexOf('-')){
+			warn('Negative CSS value ignored for '+attr);
+			value='';
+		}
+		return value;
+	}
+	function setBodyStyle(attr,value){
+		if ((undefined !== value) && ('' !== value) && ('null' !== value)){
+			document.body.style[attr] = value;
+			log('Body '+attr+' set to "'+value+'"');
+		}
+	}
+	function setMargin(){
+		//If called via V1 script, convert bodyMargin from int to str
+		if (undefined === bodyMarginStr){
+			bodyMarginStr = bodyMargin+'px';
+		}
+		setBodyStyle('margin',chkCSS('margin',bodyMarginStr));
+	}
+	function stopInfiniteResizingOfIFrame(){
+		document.documentElement.style.height = '';
+		document.body.style.height = '';
+		log('HTML & body height set to "auto"');
+	}
+	function manageTriggerEvent(options){
+		function handleEvent(){
+			sendSize(options.eventName,options.eventType);
+		}
+		var listener = {
+			add:    function(eventName){
+				addEventListener(window,eventName,handleEvent);
+			},
+			remove: function(eventName){
+				removeEventListener(window,eventName,handleEvent);
+			}
+		};
+		if(options.eventNames && Array.prototype.map){
+			options.eventName = options.eventNames[0];
+			options.eventNames.map(listener[options.method]);
+		} else {
+			listener[options.method](options.eventName);
+		}
+		log(capitalizeFirstLetter(options.method) + ' event listener: ' + options.eventType);
+	}
+	function manageEventListeners(method){
+		manageTriggerEvent({method:method, eventType: 'Animation Start',           eventNames: ['animationstart','webkitAnimationStart'] });
+		manageTriggerEvent({method:method, eventType: 'Animation Iteration',       eventNames: ['animationiteration','webkitAnimationIteration'] });
+		manageTriggerEvent({method:method, eventType: 'Animation End',             eventNames: ['animationend','webkitAnimationEnd'] });
+		manageTriggerEvent({method:method, eventType: 'Input',                     eventName:  'input' });
+		manageTriggerEvent({method:method, eventType: 'Mouse Up',                  eventName:  'mouseup' });
+		manageTriggerEvent({method:method, eventType: 'Mouse Down',                eventName:  'mousedown' });
+		manageTriggerEvent({method:method, eventType: 'Orientation Change',        eventName:  'orientationchange' });
+		manageTriggerEvent({method:method, eventType: 'Print',                     eventName:  ['afterprint', 'beforeprint'] });
+		manageTriggerEvent({method:method, eventType: 'Ready State Change',        eventName:  'readystatechange' });
+		manageTriggerEvent({method:method, eventType: 'Touch Start',               eventName:  'touchstart' });
+		manageTriggerEvent({method:method, eventType: 'Touch End',                 eventName:  'touchend' });
+		manageTriggerEvent({method:method, eventType: 'Touch Cancel',              eventName:  'touchcancel' });
+		manageTriggerEvent({method:method, eventType: 'Transition Start',          eventNames: ['transitionstart','webkitTransitionStart','MSTransitionStart','oTransitionStart','otransitionstart'] });
+		manageTriggerEvent({method:method, eventType: 'Transition Iteration',      eventNames: ['transitioniteration','webkitTransitionIteration','MSTransitionIteration','oTransitionIteration','otransitioniteration'] });
+		manageTriggerEvent({method:method, eventType: 'Transition End',            eventNames: ['transitionend','webkitTransitionEnd','MSTransitionEnd','oTransitionEnd','otransitionend'] });
+		if('child' === resizeFrom){
+			manageTriggerEvent({method:method, eventType: 'IFrame Resized',        eventName:  'resize' });
+		}
+	}
+	function checkCalcMode(calcMode,calcModeDefault,modes,type){
+		if (calcModeDefault !== calcMode){
+			if (!(calcMode in modes)){
+				warn(calcMode + ' is not a valid option for '+type+'CalculationMethod.');
+				calcMode=calcModeDefault;
+			}
+			log(type+' calculation method set to "'+calcMode+'"');
+		}
+		return calcMode;
+	}
+	function checkHeightMode(){
+		heightCalcMode = checkCalcMode(heightCalcMode,heightCalcModeDefault,getHeight,'height');
+	}
+	function checkWidthMode(){
+		widthCalcMode = checkCalcMode(widthCalcMode,widthCalcModeDefault,getWidth,'width');
+	}
+	function startEventListeners(){
+		if ( true === autoResize ) {
+			manageEventListeners('add');
+			setupMutationObserver();
+		}
+		else {
+			log('Auto Resize disabled');
+		}
+	}
+	function stopMsgsToParent(){
+		log('Disable outgoing messages');
+		sendPermit = false;
+	}
+	function removeMsgListener(){
+		log('Remove event listener: Message');
+		removeEventListener(window, 'message', receiver);
+	}
+	function disconnectMutationObserver(){
+		if (null !== bodyObserver){
+			/* istanbul ignore next */ // Not testable in PhantonJS
+			bodyObserver.disconnect();
+		}
+	}
+	function stopEventListeners(){
+		manageEventListeners('remove');
+		disconnectMutationObserver();
+		clearInterval(intervalTimer);
+	}
+	function teardown(){
+		stopMsgsToParent();
+		removeMsgListener();
+		if (true === autoResize) stopEventListeners();
+	}
+	function injectClearFixIntoBodyElement(){
+		var clearFix = document.createElement('div');
+		clearFix.style.clear   = 'both';
+		clearFix.style.display = 'block'; //Guard against this having been globally redefined in CSS.
+		document.body.appendChild(clearFix);
+	}
+	function setupInPageLinks(){
+		function getPagePosition (){
+			return {
+				x: (window.pageXOffset !== undefined) ? window.pageXOffset : document.documentElement.scrollLeft,
+				y: (window.pageYOffset !== undefined) ? window.pageYOffset : document.documentElement.scrollTop
+			};
+		}
+		function getElementPosition(el){
+			var
+				elPosition   = el.getBoundingClientRect(),
+				pagePosition = getPagePosition();
+			return {
+				x: parseInt(elPosition.left,10) + parseInt(pagePosition.x,10),
+				y: parseInt(elPosition.top,10)  + parseInt(pagePosition.y,10)
+			};
+		}
+		function findTarget(location){
+			function jumpToTarget(target){
+				var jumpPosition = getElementPosition(target);
+				log('Moving to in page link (#'+hash+') at x: '+jumpPosition.x+' y: '+jumpPosition.y);
+				sendMsg(jumpPosition.y, jumpPosition.x, 'scrollToOffset'); // X&Y reversed at sendMsg uses height/width
+			}
+			var
+				hash     = location.split('#')[1] || location, //Remove # if present
+				hashData = decodeURIComponent(hash),
+				target   = document.getElementById(hashData) || document.getElementsByName(hashData)[0];
+			if (undefined !== target){
+				jumpToTarget(target);
+			} else {
+				log('In page link (#' + hash + ') not found in iFrame, so sending to parent');
+				sendMsg(0,0,'inPageLink','#'+hash);
+			}
+		}
+		function checkLocationHash(){
+			if ('' !== location.hash && '#' !== location.hash){
+				findTarget(location.href);
+			}
+		}
+		function bindAnchors(){
+			function setupLink(el){
+				function linkClicked(e){
+					e.preventDefault();
+					/*jshint validthis:true */
+					findTarget(this.getAttribute('href'));
+				}
+				if ('#' !== el.getAttribute('href')){
+					addEventListener(el,'click',linkClicked);
+				}
+			}
+			Array.prototype.forEach.call( document.querySelectorAll( 'a[href^="#"]' ), setupLink );
+		}
+		function bindLocationHash(){
+			addEventListener(window,'hashchange',checkLocationHash);
+		}
+		function initCheck(){ //check if page loaded with location hash after init resize
+			setTimeout(checkLocationHash,eventCancelTimer);
+		}
+		function enableInPageLinks(){
+			/* istanbul ignore else */ // Not testable in phantonJS
+			if(Array.prototype.forEach && document.querySelectorAll){
+				log('Setting up location.hash handlers');
+				bindAnchors();
+				bindLocationHash();
+				initCheck();
+			} else {
+				warn('In page linking not fully supported in this browser! (See README.md for IE8 workaround)');
+			}
+		}
+		if(inPageLinks.enable){
+			enableInPageLinks();
+		} else {
+			log('In page linking not enabled');
+		}
+		return {
+			findTarget:findTarget
+		};
+	}
+	function setupPublicMethods(){
+		log('Enable public methods');
+		win.parentIFrame = {
+			autoResize: function autoResizeF(resize){
+				if (true === resize && false === autoResize) {
+					autoResize=true;
+					startEventListeners();
+					//sendSize('autoResize','Auto Resize enabled');
+				} else if (false === resize && true === autoResize) {
+					autoResize=false;
+					stopEventListeners();
+				}
+				return autoResize;
+			},
+			close: function closeF(){
+				sendMsg(0,0,'close');
+				teardown();
+			},
+			getId: function getIdF(){
+				return myID;
+			},
+			getPageInfo: function getPageInfoF(callback){
+				if ('function' === typeof callback){
+					pageInfoCallback = callback;
+					sendMsg(0,0,'pageInfo');
+				} else {
+					pageInfoCallback = function(){};
+					sendMsg(0,0,'pageInfoStop');
+				}
+			},
+			moveToAnchor: function moveToAnchorF(hash){
+				inPageLinks.findTarget(hash);
+			},
+			reset: function resetF(){
+				resetIFrame('parentIFrame.reset');
+			},
+			scrollTo: function scrollToF(x,y){
+				sendMsg(y,x,'scrollTo'); // X&Y reversed at sendMsg uses height/width
+			},
+			scrollToOffset: function scrollToF(x,y){
+				sendMsg(y,x,'scrollToOffset'); // X&Y reversed at sendMsg uses height/width
+			},
+			sendMessage: function sendMessageF(msg,targetOrigin){
+				sendMsg(0,0,'message',JSON.stringify(msg),targetOrigin);
+			},
+			setHeightCalculationMethod: function setHeightCalculationMethodF(heightCalculationMethod){
+				heightCalcMode = heightCalculationMethod;
+				checkHeightMode();
+			},
+			setWidthCalculationMethod: function setWidthCalculationMethodF(widthCalculationMethod){
+				widthCalcMode = widthCalculationMethod;
+				checkWidthMode();
+			},
+			setTargetOrigin: function setTargetOriginF(targetOrigin){
+				log('Set targetOrigin: '+targetOrigin);
+				targetOriginDefault = targetOrigin;
+			},
+			size: function sizeF(customHeight, customWidth){
+				var valString = ''+(customHeight?customHeight:'')+(customWidth?','+customWidth:'');
+				//lockTrigger();
+				sendSize('size','parentIFrame.size('+valString+')', customHeight, customWidth);
+			}
+		};
+	}
+	function initInterval(){
+		if ( 0 !== interval ){
+			log('setInterval: '+interval+'ms');
+			intervalTimer = setInterval(function(){
+				sendSize('interval','setInterval: '+interval);
+			},Math.abs(interval));
+		}
+	}
+	/* istanbul ignore next */  //Not testable in PhantomJS
+	function setupBodyMutationObserver(){
+		function addImageLoadListners(mutation) {
+			function addImageLoadListener(element){
+				if (false === element.complete) {
+					log('Attach listeners to ' + element.src);
+					element.addEventListener('load', imageLoaded, false);
+					element.addEventListener('error', imageError, false);
+					elements.push(element);
+				}
+			}
+			if (mutation.type === 'attributes' && mutation.attributeName === 'src'){
+				addImageLoadListener(mutation.target);
+			} else if (mutation.type === 'childList'){
+				Array.prototype.forEach.call(
+					mutation.target.querySelectorAll('img'),
+					addImageLoadListener
+				);
+			}
+		}
+		function removeFromArray(element){
+			elements.splice(elements.indexOf(element),1);
+		}
+		function removeImageLoadListener(element){
+			log('Remove listeners from ' + element.src);
+			element.removeEventListener('load', imageLoaded, false);
+			element.removeEventListener('error', imageError, false);
+			removeFromArray(element);
+		}
+		function imageEventTriggered(event,type,typeDesc){
+			removeImageLoadListener(event.target);
+			sendSize(type, typeDesc + ': ' + event.target.src, undefined, undefined);
+		}
+		function imageLoaded(event) {
+			imageEventTriggered(event,'imageLoad','Image loaded');
+		}
+		function imageError(event) {
+			imageEventTriggered(event,'imageLoadFailed','Image load failed');
+		}
+		function mutationObserved(mutations) {
+			sendSize('mutationObserver','mutationObserver: ' + mutations[0].target + ' ' + mutations[0].type);
+			//Deal with WebKit asyncing image loading when tags are injected into the page
+			mutations.forEach(addImageLoadListners);
+		}
+		function createMutationObserver(){
+			var
+				target = document.querySelector('body'),
+				config = {
+					attributes            : true,
+					attributeOldValue     : false,
+					characterData         : true,
+					characterDataOldValue : false,
+					childList             : true,
+					subtree               : true
+				};
+			observer = new MutationObserver(mutationObserved);
+			log('Create body MutationObserver');
+			observer.observe(target, config);
+			return observer;
+		}
+		var
+			elements         = [],
+			MutationObserver = window.MutationObserver || window.WebKitMutationObserver,
+			observer         = createMutationObserver();
+		return {
+			disconnect: function (){
+				if ('disconnect' in observer){
+					log('Disconnect body MutationObserver');
+					observer.disconnect();
+					elements.forEach(removeImageLoadListener);
+				}
+			}
+		};
+	}
+	function setupMutationObserver(){
+		var	forceIntervalTimer = 0 > interval;
+		/* istanbul ignore if */ // Not testable in PhantomJS
+		if (window.MutationObserver || window.WebKitMutationObserver){
+			if (forceIntervalTimer) {
+				initInterval();
+			} else {
+				bodyObserver = setupBodyMutationObserver();
+			}
+		} else {
+			log('MutationObserver not supported in this browser!');
+			initInterval();
+		}
+	}
+	// document.documentElement.offsetHeight is not reliable, so
+	// we have to jump through hoops to get a better value.
+	function getComputedStyle(prop,el) {
+		/* istanbul ignore next */  //Not testable in PhantomJS
+		function convertUnitsToPxForIE8(value) {
+			var PIXEL = /^\d+(px)?$/i;
+			if (PIXEL.test(value)) {
+				return parseInt(value,base);
+			}
+			var
+				style = el.style.left,
+				runtimeStyle = el.runtimeStyle.left;
+			el.runtimeStyle.left = el.currentStyle.left;
+			el.style.left = value || 0;
+			value = el.style.pixelLeft;
+			el.style.left = style;
+			el.runtimeStyle.left = runtimeStyle;
+			return value;
+		}
+		var retVal = 0;
+		el =  el || document.body;
+		/* istanbul ignore else */ // Not testable in phantonJS
+		if (('defaultView' in document) && ('getComputedStyle' in document.defaultView)) {
+			retVal = document.defaultView.getComputedStyle(el, null);
+			retVal = (null !== retVal) ? retVal[prop] : 0;
+		} else {//IE8
+			retVal =  convertUnitsToPxForIE8(el.currentStyle[prop]);
+		}
+		return parseInt(retVal,base);
+	}
+	function chkEventThottle(timer){
+		if(timer > throttledTimer/2){
+			throttledTimer = 2*timer;
+			log('Event throttle increased to ' + throttledTimer + 'ms');
+		}
+	}
+	//Idea from https://github.com/guardian/iframe-messenger
+	function getMaxElement(side,elements) {
+		var
+			elementsLength = elements.length,
+			elVal          = 0,
+			maxVal         = 0,
+			Side           = capitalizeFirstLetter(side),
+			timer          = getNow();
+		for (var i = 0; i < elementsLength; i++) {
+			elVal = elements[i].getBoundingClientRect()[side] + getComputedStyle('margin'+Side,elements[i]);
+			if (elVal > maxVal) {
+				maxVal = elVal;
+			}
+		}
+		timer = getNow() - timer;
+		log('Parsed '+elementsLength+' HTML elements');
+		log('Element position calculated in ' + timer + 'ms');
+		chkEventThottle(timer);
+		return maxVal;
+	}
+	function getAllMeasurements(dimention){
+		return [
+			dimention.bodyOffset(),
+			dimention.bodyScroll(),
+			dimention.documentElementOffset(),
+			dimention.documentElementScroll()
+		];
+	}
+	function getTaggedElements(side,tag){
+		function noTaggedElementsFound(){
+			warn('No tagged elements ('+tag+') found on page');
+			return height; //current height
+		}
+		var elements = document.querySelectorAll('['+tag+']');
+		return 0 === elements.length ?  noTaggedElementsFound() : getMaxElement(side,elements);
+	}
+	function getAllElements(){
+		return document.querySelectorAll('body *');
+	}
+	var
+		getHeight = {
+			bodyOffset: function getBodyOffsetHeight(){
+				return  document.body.offsetHeight + getComputedStyle('marginTop') + getComputedStyle('marginBottom');
+			},
+			offset: function(){
+				return getHeight.bodyOffset(); //Backwards compatability
+			},
+			bodyScroll: function getBodyScrollHeight(){
+				return document.body.scrollHeight;
+			},
+			custom: function getCustomWidth(){
+				return customCalcMethods.height();
+			},
+			documentElementOffset: function getDEOffsetHeight(){
+				return document.documentElement.offsetHeight;
+			},
+			documentElementScroll: function getDEScrollHeight(){
+				return document.documentElement.scrollHeight;
+			},
+			max: function getMaxHeight(){
+				return Math.max.apply(null,getAllMeasurements(getHeight));
+			},
+			min: function getMinHeight(){
+				return Math.min.apply(null,getAllMeasurements(getHeight));
+			},
+			grow: function growHeight(){
+				return getHeight.max(); //Run max without the forced downsizing
+			},
+			lowestElement: function getBestHeight(){
+				return Math.max(getHeight.bodyOffset(), getMaxElement('bottom',getAllElements()));
+			},
+			taggedElement: function getTaggedElementsHeight(){
+				return getTaggedElements('bottom','data-iframe-height');
+			}
+		},
+		getWidth = {
+			bodyScroll: function getBodyScrollWidth(){
+				return document.body.scrollWidth;
+			},
+			bodyOffset: function getBodyOffsetWidth(){
+				return document.body.offsetWidth;
+			},
+			custom: function getCustomWidth(){
+				return customCalcMethods.width();
+			},
+			documentElementScroll: function getDEScrollWidth(){
+				return document.documentElement.scrollWidth;
+			},
+			documentElementOffset: function getDEOffsetWidth(){
+				return document.documentElement.offsetWidth;
+			},
+			scroll: function getMaxWidth(){
+				return Math.max(getWidth.bodyScroll(), getWidth.documentElementScroll());
+			},
+			max: function getMaxWidth(){
+				return Math.max.apply(null,getAllMeasurements(getWidth));
+			},
+			min: function getMinWidth(){
+				return Math.min.apply(null,getAllMeasurements(getWidth));
+			},
+			rightMostElement: function rightMostElement(){
+				return getMaxElement('right', getAllElements());
+			},
+			taggedElement: function getTaggedElementsWidth(){
+				return getTaggedElements('right', 'data-iframe-width');
+			}
+		};
+	function sizeIFrame(triggerEvent, triggerEventDesc, customHeight, customWidth){
+		function resizeIFrame(){
+			height = currentHeight;
+			width  = currentWidth;
+			sendMsg(height,width,triggerEvent);
+		}
+		function isSizeChangeDetected(){
+			function checkTolarance(a,b){
+				var retVal = Math.abs(a-b) <= tolerance;
+				return !retVal;
+			}
+			currentHeight = (undefined !== customHeight)  ? customHeight : getHeight[heightCalcMode]();
+			currentWidth  = (undefined !== customWidth )  ? customWidth  : getWidth[widthCalcMode]();
+			return	checkTolarance(height,currentHeight) || (calculateWidth && checkTolarance(width,currentWidth));
+		}
+		function isForceResizableEvent(){
+			return !(triggerEvent in {'init':1,'interval':1,'size':1});
+		}
+		function isForceResizableCalcMode(){
+			return (heightCalcMode in resetRequiredMethods) || (calculateWidth && widthCalcMode in resetRequiredMethods);
+		}
+		function logIgnored(){
+			log('No change in size detected');
+		}
+		function checkDownSizing(){
+			if (isForceResizableEvent() && isForceResizableCalcMode()){
+				resetIFrame(triggerEventDesc);
+			} else if (!(triggerEvent in {'interval':1})){
+				logIgnored();
+			}
+		}
+		var	currentHeight,currentWidth;
+		if (isSizeChangeDetected() || 'init' === triggerEvent){
+			lockTrigger();
+			resizeIFrame();
+		} else {
+			checkDownSizing();
+		}
+	}
+	var sizeIFrameThrottled = throttle(sizeIFrame);
+	function sendSize(triggerEvent, triggerEventDesc, customHeight, customWidth){
+		function recordTrigger(){
+			if (!(triggerEvent in {'reset':1,'resetPage':1,'init':1})){
+				log( 'Trigger event: ' + triggerEventDesc );
+			}
+		}
+		function isDoubleFiredEvent(){
+			return  triggerLocked && (triggerEvent in doubleEventList);
+		}
+		if (!isDoubleFiredEvent()){
+			recordTrigger();
+			sizeIFrameThrottled(triggerEvent, triggerEventDesc, customHeight, customWidth);
+		} else {
+			log('Trigger event cancelled: '+triggerEvent);
+		}
+	}
+	function lockTrigger(){
+		if (!triggerLocked){
+			triggerLocked = true;
+			log('Trigger event lock on');
+		}
+		clearTimeout(triggerLockedTimer);
+		triggerLockedTimer = setTimeout(function(){
+			triggerLocked = false;
+			log('Trigger event lock off');
+			log('--');
+		},eventCancelTimer);
+	}
+	function triggerReset(triggerEvent){
+		height = getHeight[heightCalcMode]();
+		width  = getWidth[widthCalcMode]();
+		sendMsg(height,width,triggerEvent);
+	}
+	function resetIFrame(triggerEventDesc){
+		var hcm = heightCalcMode;
+		heightCalcMode = heightCalcModeDefault;
+		log('Reset trigger event: ' + triggerEventDesc);
+		lockTrigger();
+		triggerReset('reset');
+		heightCalcMode = hcm;
+	}
+	function sendMsg(height,width,triggerEvent,msg,targetOrigin){
+		function setTargetOrigin(){
+			if (undefined === targetOrigin){
+				targetOrigin = targetOriginDefault;
+			} else {
+				log('Message targetOrigin: '+targetOrigin);
+			}
+		}
+		function sendToParent(){
+			var
+				size  = height + ':' + width,
+				message = myID + ':' +  size + ':' + triggerEvent + (undefined !== msg ? ':' + msg : '');
+			log('Sending message to host page (' + message + ')');
+			target.postMessage( msgID + message, targetOrigin);
+		}
+		if(true === sendPermit){
+			setTargetOrigin();
+			sendToParent();
+		}
+	}
+	function receiver(event) {
+		function isMessageForUs(){
+			return msgID === (''+event.data).substr(0,msgIdLen); //''+ Protects against non-string messages
+		}
+		function initFromParent(){
+			function fireInit(){
+				initMsg = event.data;
+				target  = event.source;
+				init();
+				firstRun = false;
+				setTimeout(function(){ initLock = false;},eventCancelTimer);
+			}
+			if (document.body){
+				fireInit();
+			} else {
+				log('Waiting for page ready');
+				addEventListener(window,'readystatechange',initFromParent);
+			}
+		}
+		function resetFromParent(){
+			if (!initLock){
+				log('Page size reset by host page');
+				triggerReset('resetPage');
+			} else {
+				log('Page reset ignored by init');
+			}
+		}
+		function resizeFromParent(){
+			sendSize('resizeParent','Parent window requested size check');
+		}
+		function moveToAnchor(){
+			var anchor = getData();
+			inPageLinks.findTarget(anchor);
+		}
+		function getMessageType(){
+			return event.data.split(']')[1].split(':')[0];
+		}
+		function getData(){
+			return event.data.substr(event.data.indexOf(':')+1);
+		}
+		function isMiddleTier(){
+			return ('iFrameResize' in window);
+		}
+		function messageFromParent(){
+			var msgBody = getData();
+			log('MessageCallback called from parent: ' + msgBody );
+			messageCallback(JSON.parse(msgBody));
+			log(' --');
+		}
+		function pageInfoFromParent(){
+			var msgBody = getData();
+			log('PageInfoFromParent called from parent: ' + msgBody );
+			pageInfoCallback(JSON.parse(msgBody));
+			log(' --');
+		}
+		function isInitMsg(){
+			//Test if this message is from a child below us. This is an ugly test, however, updating
+			//the message format would break backwards compatibity.
+			return event.data.split(':')[2] in {'true':1,'false':1};
+		}
+		function callFromParent(){
+			switch (getMessageType()){
+			case 'reset':
+				resetFromParent();
+				break;
+			case 'resize':
+				resizeFromParent();
+				break;
+			case 'inPageLink':
+			case 'moveToAnchor':
+				moveToAnchor();
+				break;
+			case 'message':
+				messageFromParent();
+				break;
+			case 'pageInfo':
+				pageInfoFromParent();
+				break;
+			default:
+				if (!isMiddleTier() && !isInitMsg()){
+					warn('Unexpected message ('+event.data+')');
+				}
+			}
+		}
+		function processMessage(){
+			if (false === firstRun) {
+				callFromParent();
+			} else if (isInitMsg()) {
+				initFromParent();
+			} else {
+				log('Ignored message of type "' + getMessageType() + '". Received before initialization.');
+			}
+		}
+		if (isMessageForUs()){
+			processMessage();
+		}
+	}
+	//Normally the parent kicks things off when it detects the iFrame has loaded.
+	//If this script is async-loaded, then tell parent page to retry init.
+	function chkLateLoaded(){
+		if('loading' !== document.readyState){
+			window.parent.postMessage('[iFrameResizerChild]Ready','*');
+		}
+	}
+	addEventListener(window, 'message', receiver);
+	chkLateLoaded();
+})(window || {});