RubyGems - j1m_scroll - Versions diffs - 0.0.1 - Mend

j1m_scroll 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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 || {});