survivalkit 0.3.2 → 0.3.3

data/templates/drupal/sources/deorphan/jquery.deorphan.min.js

@@ -0,0 +1 @@
+(function($){$.fn.deOrphan=function(){function _deOrphan(node){$(node).contents().each(function(){if(this.nodeType==3){this.textContent=this.textContent.replace(/ (\S*)$/,'\u00A0$1');}else{_deOrphan(this);}});}return this.each(function(i,el){_deOrphan(el);});};})(jQuery);

data/templates/drupal/sources/flexie/README.md

@@ -0,0 +1,142 @@
+Cross-browser support for the [CSS3 Flexible Box Model](http://www.w3.org/TR/css3-flexbox/). Check out [The Playground](http://flexiejs.com/playground/) to see it in action.
+# Flexie v1.0 [![](http://stillmaintained.com/doctyper/flexie.png)](http://stillmaintained.com/doctyper/flexie)
+
+## Browser Support
+* IE 6-9
+* Opera 10.0+
+
+The Flexible Box Model is [supported natively](http://www.caniuse.com/#feat=flexbox) by these browsers:
+
+* Firefox 3.0+
+* Safari 3.2+
+* Chrome 5.0+
+
+In addition, Flexie attempts to normailze browser inconsistencies with the flexible box model.
+
+### Currently Supported Properties
+* box-orient
+* box-align
+* box-direction
+* box-pack
+* box-flex
+* box-flex-group
+* box-ordinal-group
+
+## Why?
+I *really* wanted to use the CSS3 Flexible Box Model.
+
+## How?
+It works like [Selectivizr](http://selectivizr.com). In fact, it uses Selectivizr's engine to traverse your style sheets and looks for `display: box` elements. After that, it looks for any of the currently supported properties.
+
+Note: Flexie looks for non-vendor-prefixed properties. For example, it will ignore `-moz-box-pack`, but not `box-pack`. For best results, make sure to use a non-vendor-prefixed property _in addition to_ your prefixed properties. But you were already doing that to future-proof your code, weren't you?
+
+No setup on your end, just stick Flexie in your markup after your [selector engine of choice](http://selectivizr.com/#things).
+
+## Requirements
+See the [things you need to know](http://selectivizr.com/#things)
+
+## Caveats
+* For older browsers (IE < 8), please remember that some advanced selectors (child, adjacent, pseudo-selectors) will fail. Flexie does not attempt to bridge this gap, so if you must support legacy browsers, class names and ID selectors are your best bets.
+
+* As of FF 4.0 / Chrome 7 / Safari 5, Gecko and Webkit differ slightly in their flexbox implementations. <strike>Of note is their default values. Webkit will default to `box-align: start`, while Gecko defaults to the spec-defined `box-align: stretch`. Make sure your flexbox CSS works on both these browsers before adding Flexie.</strike>
+	* As of version 0.7, Flexie normalizes the `box-align` property across Webkit browsers.
+	* As of version 0.8, Flexie normalizes the `box-pack` property in Gecko.
+
+* Be careful of pseudo-selectors (i.e., `:nth-child`, `:first-child`). While native flexbox does not modify the DOM, Flexie must. Thus, your CSS properties might not apply as intended. For example, if you use a combination of `box-direction: reverse` and a `:first-child` selector, that selector will target the wrong element. And if you followed all of that, congratulations.
+
+* There may be cases where the floats used to mimic the flexbox layout drop in Internet Explorer browsers. If possible, you can try the [overflow fix](http://css-tricks.com/all-about-floats/) to snap these into place _(Flexie assumes it cannot use this as a workaround due to the impact this may have in your layouts)_.
+
+* As of YUI 2.8.2r1, YUI's selector engine does not recognize dashed attributes (i.e. [data-name="foo"]). Flexie uses several [data- attributes](http://ejohn.org/blog/html-5-data-attributes/) as element flags. A bug report [has been filed](http://yuilibrary.com/projects/yui2/ticket/2529254) about this issue, but in the meantime YUI remains incompatible with Flexie.
+
+## Asynchronous API
+You can run Flexie asynchronously in case you cannot purely on style sheets. All parameters are optional, unless otherwise stated:
+
+### Creating a new Flexie Object
+	var box = new Flexie.box({
+		target : document.getElementById("foo"),
+		orient : "horizontal",
+		align : "stretch",
+		direction : "normal",
+		pack : "start",
+		flexMatrix : [1, 1, 1, 1],
+		ordinalMatrix : [0, 0, 0, 0]
+	});
+
+*	**target**
+	(required) The flexbox parent element. This must be a DOM node.
+*	**orient**
+	(optional) Possible values: `horizontal`, `vertical`
+*	**align**
+	(optional) Possible values: `stretch`, `start`, `end`, `center`
+*	**direction**
+	(optional) Possible values: `normal`, `reverse`
+*	**pack**
+	(optional) Possible values: `start`, `end`, `center`, `justify`
+*	**flexMatrix**
+	(optional) An array of values to apply to the parent's children. e.g.:
+		flexMatrix : [1, 0, 0] // Three child nodes contained, the parent's first child has a box-flex value of 1
+		flexMatrix : [1, 0, 1] // Three child nodes contained, the parent's first and last child have a box-flex value of 1
+		flexMatrix : [1, 1, 1] // Three child nodes contained, all children have a box-flex value of 1
+*	**ordinalMatrix**
+	(optional) An array of values to apply to the parent's children. See `flexMatrix` for an example.
+
+### Flexie.updateInstance(target, params)
+Used to redraw currently active Flexie objects (i.e., after dynamically updating a flexbox element). All parameters optional.
+
+_Note: Calling this method without parameters will update all instances._
+
+*	**target**
+	(optional) The flexbox element to update.
+*	**params**
+	(optional) An object of flexbox properties to update. See Creating a new Flexie Object for accepted parameters.
+
+### Flexie.getInstance(target)
+Returns the target instance
+
+*	**target**
+	(optional) The flexbox instance to retrieve.
+	
+### Flexie.destroyInstance(target)
+Destroys the target instance.
+
+_Note: Calling this method without parameters will destroy all instances._
+
+*	**target**
+	(optional) The flexbox instance to retrieve.
+	
+### Flexie.flexboxSupported
+An exposed object detailing the level of flexbox support. Returns false for no support.
+
+## Acknowledgements
+Selectivizr, for their fantastic CSS parsing engine.
+
+## Copyright and Software License
+The MIT License
+
+Copyright (c) 2010 Richard Herrera
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+## Contact
+* rich {at} doctyper {dot} com
+* [@doctyper](http://twitter.com/doctyper) on Twitter
+* <http://doctyper.com>
+
+## Links
+* Flexie on GitHub: <http://github.com/doctyper/flexie>

data/templates/drupal/sources/flexie/demo/css/box-flex.css

@@ -0,0 +1,30 @@
+#box-parent {
+	width: 100%; /* Firefox needs this */
+	height: 100%;
+}
+
+#box-parent, #box-child-2, #nested-child-2 {
+	display: -webkit-box;
+	display: -moz-box;
+	display: box;
+	
+	-webkit-box-orient: vertical;
+	-moz-box-orient: vertical;
+	box-orient: vertical;
+	
+	-webkit-box-direction: reverse;
+	-moz-box-direction: reverse;
+	box-direction: reverse;
+}
+
+#box-parent div {
+	-webkit-box-flex: 1;
+	-moz-box-flex: 1;
+	box-flex: 1;
+}
+
+#box-child-2 {
+	-webkit-box-ordinal-group: 2;
+	-moz-box-ordinal-group: 2;
+	box-ordinal-group: 2;
+}

data/templates/drupal/sources/flexie/demo/index.html

@@ -0,0 +1,108 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+		<title>Flexie Demo</title>
+		
+		<!-- Flexie -->
+		<style type="text/css" media="screen">
+			* {
+				margin: 0;
+				padding: 0;
+				border: 0;
+			}
+			
+			html, body {
+				width: 100%;
+				height: 100%;
+			}
+
+			body {
+				background: #444;
+				text-align: center;
+				color: #ddd;
+				font: bold 14px "Helvetica Neue", Helvetica, Arial, sans-serif;
+			}
+
+			#box-child-1 {
+				background: #111;
+			}
+
+			#box-child-2 {
+				background: #222;
+			}
+
+			#box-child-3 {
+				background: #333;
+			}
+
+			#nested-child-1 {
+				background: #444;
+			}
+
+			#nested-child-2 {
+				background: #555;
+			}
+
+			#nested-child-3 {
+				background: #666;
+			}
+
+			#deep-child-1 {
+				background: #777;
+			}
+
+			#deep-child-2 {
+				background: #888;
+			}
+
+			#deep-child-3 {
+				background: #999;
+			}
+		</style>
+		<link rel="stylesheet" href="css/box-flex.css" type="text/css" />
+	</head>
+	<body>
+		<div id="box-parent">
+			<div id="box-child-1"><span>Box Child 1</span></div>
+			<div id="box-child-2">
+				<div id="nested-child-1"><span>Nested Child 1</span></div>
+				<div id="nested-child-2">
+					<div id="deep-child-1"><span>Deep Child 1</span></div>
+					<div id="deep-child-2"><span>Deep Child 2</span></div>
+					<div id="deep-child-3"><span>Deep Child 3</span></div>
+				</div>
+				<div id="nested-child-3"><span>Nested Child 3</span></div>
+			</div>
+			<div id="box-child-3"><span>Box Child 3</span></div>
+		</div>
+		
+		<!-- DOMAssistant -->
+		<!-- <script src="http://domassistant.googlecode.com/svn/branches/2.8/DOMAssistantCompressed.js" type="text/javascript"></script> -->
+		
+		<!-- NWMatcher -->
+		<!-- <script src="http://nwevents.googlecode.com/svn/trunk/nwmatcher.js" type="text/javascript"></script> -->
+		
+		<!-- jQuery -->
+		<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min.js" type="text/javascript"></script>
+		
+		<!-- Sizzle -->
+		<!-- <script src="http://github.com/jeresig/sizzle/raw/master/sizzle.js" type="text/javascript"></script> -->
+		
+		<!-- MooTools -->
+		<!-- <script src="https://ajax.googleapis.com/ajax/libs/mootools/1.3.0/mootools-yui-compressed.js" type="text/javascript"></script> -->
+		
+		<!-- YUI -->
+		<!-- <script src="http://yui.yahooapis.com/2.8.1/build/yahoo/yahoo-min.js"></script> -->
+		<!-- <script src="http://yui.yahooapis.com/2.8.1/build/selector/selector-min.js"></script> -->
+		
+		<!-- Prototype -->
+		<!-- <script src="https://ajax.googleapis.com/ajax/libs/prototype/1.6.1.0/prototype.js" type="text/javascript"></script> -->
+		
+		<!-- Dojo -->
+		<!-- <script src="https://ajax.googleapis.com/ajax/libs/dojo/1.5/dojo/dojo.xd.js" type="text/javascript"></script> -->
+		
+		<!-- Flexie -->
+		<script src="/src/flexie.js" type="text/javascript"></script>
+	</body>
+</html>

data/templates/drupal/sources/flexie/dist/flexie.min.js

@@ -0,0 +1,33 @@
+var Flexie=function(x,E){function F(a){if(a)a=a.replace(wa,v).replace(xa,v);return a}function h(a,d){var c,b=0,e=a?a.length:W;if(e===W)for(c in a){if(a.hasOwnProperty(c))if(d.call(a[c],c,a[c])===I)break}else for(c=a[0];b<e&&d.call(c,b,c)!==I;c=a[++b]);}function ya(){var a;h(X,function(d,c){if(x[d]&&!a)if(a=eval(c.s.replace("*",d))){Y=d;return false}});return a}function Z(a,d){a="on"+a;var c=x[a];x[a]=typeof x[a]!=="function"?d:function(){c&&c();d()}}function $(a){var d=a.nodeName.toLowerCase();if(a.id)d+=
+"#"+a.id;else if(a.FLX_DOM_ID)d+="["+aa+"='"+a.FLX_DOM_ID+"']";return d}function S(a){if(!a.FLX_DOM_ID){T+=1;a.FLX_DOM_ID=T;a.setAttribute(aa,a.FLX_DOM_ID)}}function za(a){var d=[],c,b,e,f,g,i;a=a.replace(Aa,v);a=a.replace(/\s?(\{|\:|\})\s?/g,P);a=a.split(ba);h(a,function(j,l){if(l){c=[l,ba].join(v);if((b=/(.*)\{(.*)\}/.exec(c))&&b[2]){e=b[1];f=b[2].split(";");i=[];h(f,function(m,r){g=r.split(":");g.length&&g[1]&&i.push({property:g[0],value:g[1]})});e&&i.length&&d.push({selector:e,properties:i})}}});
+return d}function Ba(a){var d,c,b,e,f,g=/\s?,\s?/,i,j,l={},m={};i=function(r,n,o,k){var p={selector:F(r),properties:[]};h(n.properties,function(s,w){p.properties.push({property:F(w.property),value:F(w.value)})});if(o&&k)p[o]=k;return p};j=function(r,n,o,k){var p=o&&k?l[r]:m[r],s;if(p){h(n.properties,function(w,B){h(p.properties,function(M,A){if(B.property===A.property){s=M;return false}});if(s)p.properties[s]=B;else p.properties.push(B)});if(o&&k)p[o]=k}else if(o&&k)l[r]=i(r,n,o,k);else m[r]=i(r,
+n,t,t)};h(a,function(r,n){d=F(n.selector).replace(g,",").split(g);h(d,function(o,k){k=F(k);c=n.properties;h(c,function(p,s){b=F(s.property);e=F(s.value);if(b){f=b.replace("box-",v);switch(f){case "display":e==="box"&&j(k,n,t,t);break;case "orient":case "align":case "direction":case "pack":j(k,n,t,t);break;case "flex":case "flex-group":case "ordinal-group":j(k,n,f,e)}}})})});h(m,function(r,n){y.push(n)});h(l,function(r,n){ca.push(n)});return{boxes:y,children:ca}}function da(a,d,c){var b,e,f=[];h(c,
+function(g,i){if(i.selector){b=d(i.selector);b=b[0]?b:[b];b[0]&&h(b,function(j,l){switch(l.nodeName.toLowerCase()){case "script":case "style":case "link":break;default:if(l.parentNode===a){S(l);e={};h(i,function(m){e[m]=i[m]});e.match=l;f.push(e)}}})}else{S(i);f.push({match:i,selector:$(i)})}});return f}function Ca(a){h(a,function(d,c){a[d]=c||Da[d]});return a}function Ea(a){var d,c,b,e,f,g,i,j,l,m,r,n,o,k,p={},s,w,B,M="["+Q+"]";if(a){h(a.boxes,function(A,C){C.selector=F(C.selector);d=C.selector;
+c=C.properties;g=i=j=l=m=t;h(c,function(Fa,G){b=F(G.property);e=F(G.value);if(b){f=b.replace("box-",v);switch(f){case "display":if(e==="box")g=e;break;case "orient":i=e;break;case "align":j=e;break;case "direction":l=e;break;case "pack":m=e}}});r=J;n=r(C.selector);n=n[0]?n:[n];h(n,function(Fa,G){if(G.nodeType){S(G);o=da(G,r,a.children);B=d+" "+M;k={target:G,selector:d,properties:c,children:o,display:g,orient:i,align:j,direction:l,pack:m,nested:B};if(s=p[G.FLX_DOM_ID])h(k,function(K,N){switch(K){case "selector":if(N&&
+!RegExp(N).test(s[K]))s[K]+=", "+N;break;case "children":h(k[K],function(Xa,ea){w=I;h(s[K],function(Ya,Ga){if(ea.match.FLX_DOM_ID===Ga.match.FLX_DOM_ID)w=q});w||s[K].push(ea)});break;default:if(N)s[K]=N}});else{p[G.FLX_DOM_ID]=Ca(k);p[G.FLX_DOM_ID].target.setAttribute(Q,q)}}})});fa=J(M);y={};h(fa,function(A,C){y[C.FLX_DOM_ID]=p[C.FLX_DOM_ID]});h(y,function(A,C){C.display==="box"&&new z.box(C)})}}function ga(a,d,c){c=c.replace(c.charAt(0),c.charAt(0).toUpperCase());var b=a["offset"+c]||0;b&&h(d,function(e,
+f){f=parseFloat(a.currentStyle[f]);isNaN(f)||(b-=f)});return b}function ha(a,d){var c,b,e=a.currentStyle&&a.currentStyle[d],f=a.style;if(!ia.test(e)&&Ha.test(e)){c=f.left;b=a.runtimeStyle.left;a.runtimeStyle.left=a.currentStyle.left;f.left=e||0;e=f.pixelLeft+"px";f.left=c||0;a.runtimeStyle.left=b}return e}function u(a,d,c){if(x.getComputedStyle)a=x.getComputedStyle(a,t)[d];else if(Ia.test(d)){var b=a&&a.currentStyle?a.currentStyle[d]:0;if(!ia.test(b)){if(b==="auto"||b==="medium"){switch(d){case "width":b=
+[ja,ka,la,ma];b=ga(a,b,d);break;case "height":b=[U,na,oa,pa];b=ga(a,b,d);break;default:b=ha(a,d)}a=b}else a=ha(a,d);b=a}a=b}else a=a.currentStyle[d];if(c){a=parseInt(a,10);if(isNaN(a))a=0}return a}function Ja(a){return a.innerWidth||a.clientWidth}function Ka(a){return a.innerHeight||a.clientHeight}function V(a,d,c,b){var e=[];h(La,function(f,g){e.push((b?g:v)+d+":"+(!b?g:v)+c)});a.style.cssText+=e.join(";");return a}function D(a,d,c){h(a&&a[0]?a:[a],function(b,e){if(e&&e.style)e.style[d]=c?c+"px":
+v})}function Ma(a){var d,c;a=a.replace(Na,function(b,e){return"%"+e}).replace(/\s|\>|\+|\~/g,"%").split(/%/g);d={_id:100,_class:10,_tag:1};c=0;h(a,function(b,e){if(/#/.test(e))c+=d._id;else if(/\.|\[|\:/.test(e))c+=d._class;else if(/[a-zA-Z]+/.test(e))c+=d._tag});return c}function Oa(a,d,c){var b=[],e,f=(c?"ordinal":"flex")+"Specificity";h(a,function(g,i){if(!c&&i.flex||c&&i["ordinal-group"]){i[f]=i[f]||Ma(i.selector);e=I;h(b,function(j,l){if(l.match===i.match){if(l[f]<i[f])b[j]=i;e=q;return I}});
+e||b.push(i)}});return b}function R(a,d,c){var b={},e=[],f=0,g;a=Oa(a,d,c);h(d,function(i,j){h(a,function(l,m){if(c){g=m["ordinal-group"]||"1";if(m.match===j){m.match.setAttribute("data-ordinal-group",g);b[g]=b[g]||[];b[g].push(m)}}else{g=m.flex||"0";if(m.match===j&&(!m[g]||m[g]&&parseInt(m[g],10)<=1)){f+=parseInt(g,10);b[g]=b[g]||[];b[g].push(m)}}});if(c&&!j.getAttribute("data-ordinal-group")){g="1";j.setAttribute("data-ordinal-group",g);b[g]=b[g]||[];b[g].push({match:j})}});h(b,function(i){e.push(i)});
+e.sort(function(i,j){return j-i});return{keys:e,groups:b,total:f}}function qa(a,d,c){a=d.nodes;var b,e=true;for(b=function(f){return f.offsetTop-u(f,c.anti.pos,q)};e&&b(a[0])!==b(a[a.length-1]);)h(a,function(f,g){if(!d.hasFlex||g.getAttribute("data-flex")){e=Math.max(0,u(g,c.props.dim,q)-1);g.style[c.props.dim]=e}})}function Pa(){if(!ra){var a,d,c,b,e=E.body,f=E.documentElement;Z("resize",function(){c=x.innerWidth||f.innerWidth||f.clientWidth||e.clientWidth;b=x.innerHeight||f.innerHeight||f.clientHeight||
+e.clientHeight;if(a!==c||d!==b){z.updateInstance(t,t);a=c;d=b}});ra=q}}function sa(a){var d,c;h(a,function(b,e){d=e.style.width;c=e.style.height;e.style.cssText=v;e.style.width=d;e.style.height=c})}function O(a,d){var c=[],b,e,f;e=0;for(f=d.length;e<f;e++)if(b=d[e])switch(b.nodeName.toLowerCase()){case "script":case "style":case "link":break;default:if(b.nodeType===1)c.push(b);else if(b.nodeType===3&&(b.isElementContentWhitespace||Qa.test(b.data))){a.removeChild(b);e--}}return c}function ta(a){var d=
+0;a=a.parentNode;for(var c;a.FLX_DOM_ID;){c=y[a.FLX_DOM_ID];c=R(c.children,O(a,a.childNodes),t);d+=c.total;c=q;a=a.parentNode}return{nested:c,flex:d}}function Ra(a,d){var c=a.parentNode,b;if(c.FLX_DOM_ID){c=y[c.FLX_DOM_ID];h(c.properties,function(e,f){if(RegExp(d).test(f.property)){b=q;return I}})}return b}function Sa(a){a.flexMatrix&&h(a.children,function(d,c){c.flex=a.flexMatrix[d]});a.ordinalMatrix&&h(a.children,function(d,c){c["ordinal-group"]=a.ordinalMatrix[d]});return a}function Ta(a,d){var c=
+a.target;if(!c.FLX_DOM_ID)c.FLX_DOM_ID=c.FLX_DOM_ID||++T;if(!a.nodes)a.nodes=O(c,c.childNodes);if(!a.selector){a.selector=$(c);c.setAttribute(Q,q)}if(!a.properties)a.properties=[];if(!a.children)a.children=da(c,J,O(c,c.childNodes));if(!a.nested)a.nested=a.selector+" ["+Q+"]";a.target=c;a._instance=d;return a}var z={},T=0,aa="data-flexie-id",Q="data-flexie-parent",H,Y,X={NW:{s:"*.Dom.select"},DOMAssistant:{s:"*.$",m:"*.DOMReady"},Prototype:{s:"$$",m:"document.observe",p:"dom:loaded",c:"document"},
+YAHOO:{s:"*.util.Selector.query",m:"*.util.Event.onDOMReady",c:"*.util.Event"},MooTools:{s:"$$",m:"window.addEvent",p:"domready"},Sizzle:{s:"*"},jQuery:{s:"*",m:"*(document).ready"},dojo:{s:"*.query",m:"*.addOnLoad"}},J,ia=/^-?\d+(?:px)?$/i,Ha=/^-?\d/,Ia=/width|height|margin|padding|border/,Ua=/(msie) ([\w.]+)/,Aa=/\t|\n|\r/g,Va=/^max\-([a-z]+)/,Wa=/^https?:\/\//i,wa=/^\s\s*/,xa=/\s\s*$/,Qa=/^\s*$/,Na=/\s?(\#|\.|\[|\:(\:)?[^first\-(line|letter)|before|after]+)/g,v="",ua=" ",P="$1",ka="paddingRight",
+na="paddingBottom",ja="paddingLeft",U="paddingTop",ma="borderRightWidth",pa="borderBottomWidth",la="borderLeftWidth",oa="borderTopWidth",ba="}",La=" -o- -moz- -ms- -webkit- -khtml- ".split(ua),Da={orient:"horizontal",align:"stretch",direction:"inherit",pack:"start"},y=[],ca=[],fa,ra,q=true,I=false,t=null,W,L={IE:function(){var a,d=Ua.exec(x.navigator.userAgent.toLowerCase());if(d)a=parseInt(d[2],10);return a}()},va;va=function(){function a(o){return o.replace(j,function(k,p,s){k=s.split(",");h(k,
+function(w,B){B.replace(l,P).replace(m,P).replace(n,P).replace(r,ua)});return p+k.join(",")})}function d(){if(x.XMLHttpRequest)return new x.XMLHttpRequest;try{return new x.ActiveXObject("Microsoft.XMLHTTP")}catch(o){return t}}function c(o){var k=d();k.open("GET",o,I);k.send();return k.status===200?k.responseText:v}function b(o,k){if(o){if(Wa.test(o))return k.substring(0,k.indexOf("/",8))===o.substring(0,o.indexOf("/",8))?o:t;if(o.charAt(0)==="/")return k.substring(0,k.indexOf("/",8))+o;var p=k.split("?")[0];
+if(o.charAt(0)!=="?"&&p.charAt(p.length-1)!=="/")p=p.substring(0,p.lastIndexOf("/")+1);return p+o}}function e(o){if(o)return c(o).replace(f,v).replace(g,function(k,p,s){return e(b(s,o))}).replace(i,function(k,p,s){p=p||v;return" url("+p+b(s,o)+p+") "});return v}var f=/(\/\*[^*]*\*+([^\/][^*]*\*+)*\/)\s*/g,g=/@import\s*(?:url\(\s*?)?(["'])?(.*?)\1\s*\)?[\w\W]*?;/g,i=/\surl\((["'])?([^"')]+)\1\)/g,j=/(^|\})\s*([^\{]*?[\[:][^\{]+)/g,l=/([(\[+~])\s+/g,m=/\s+([)\]+~])/g,r=/\s+/g,n=/^\s*((?:[\S\s]*\S)?)\s*$/;
+return function(){var o,k,p;k=E.getElementsByTagName("BASE");var s=k.length>0?k[0].href:E.location.href,w;k=0;for(p=E.styleSheets.length;k<p;k++)if((o=E.styleSheets[k])&&o.href!==t)if(o=b(o.href,s)){w=a(e(o));w=za(w);w=Ba(w)}Ea(w)}}();z.box=function(a){return this.renderModel(a)};z.box.prototype={properties:{boxModel:function(a,d,c){var b,e;a.style.display="block";if(L.IE===8)a.style.overflow="hidden";if(!c.cleared){selectors=c.selector.split(/\s?,\s?/);b=E.styleSheets;b=b[b.length-1];e="padding-top:"+
+(u(a,U,t)||"0.1px;");h(selectors,function(f,g){if(b.addRule)if(L.IE<8){a.style.zoom="1";if(L.IE===6)b.addRule(g.replace(/\>|\+|\~/g,""),e+"zoom:1;",0);else L.IE===7&&b.addRule(g,e+"display:inline-block;",0)}else{b.addRule(g,e,0);b.addRule(g+":before","content: '.';display: block;height: 0;overflow: hidden",0);b.addRule(g+":after","content: '.';display: block;height: 0;overflow: hidden;clear:both;",0)}else if(b.insertRule){b.insertRule(g+"{"+e+"}",0);b.insertRule(g+":after{content: '.';display: block;height: 0;overflow: hidden;clear:both;}",
+0)}});c.cleared=q}},boxDirection:function(a,d,c){var b;if(c.direction==="reverse"&&!c.reversed||c.direction==="normal"&&c.reversed){d=d.reverse();h(d,function(e,f){a.appendChild(f)});d=J(c.nested);h(d,function(e,f){if((b=y[f.FLX_DOM_ID])&&b.direction==="inherit")b.direction=c.direction});c.reversed=!c.reversed}},boxOrient:function(a,d,c){var b;a={pos:"marginLeft",opp:"marginRight",dim:"width",out:"offsetWidth",func:Ja,pad:[ja,ka,la,ma]};b={pos:"marginTop",opp:"marginBottom",dim:"height",out:"offsetHeight",
+func:Ka,pad:[U,na,oa,pa]};H||h(d,function(e,f){f.style[L.IE>=9?"cssFloat":"styleFloat"]="left";if(c.orient==="vertical"||c.orient==="block-axis")f.style.clear="left";if(L.IE===6)f.style.display="inline"});switch(c.orient){case "vertical":case "block-axis":this.props=b;this.anti=a;break;default:this.props=a;this.anti=b}},boxOrdinalGroup:function(a,d,c){var b,e;if(d.length){b=function(f){f=f.keys;h(c.reversed?f:f.reverse(),function(g,i){h(d,function(j,l){i===l.getAttribute("data-ordinal-group")&&a.appendChild(l)})})};
+e=R(c.children,d,q);e.keys.length>1&&b(e)}},boxFlex:function(a,d,c){var b=this,e,f,g,i;if(d.length){e=function(j){var l=j.groups,m;h(j.keys,function(r,n){h(l[n],function(o,k){m=t;h(k.properties,function(p,s){if(Va.test(s.property))m=parseFloat(s.value)});if(!m||k.match[b.props.out]>m)D(k.match,b.props.pos,t)})})};f=function(j){var l=0,m;h(d,function(r,n){l+=u(n,b.props.dim,q);h(b.props.pad,function(o,k){l+=u(n,k,q)});l+=u(n,b.props.pos,q);l+=u(n,b.props.opp,q)});m=a[b.props.out]-l;h(b.props.pad,function(r,
+n){m-=u(a,n,q)});return{whitespace:m,ration:m/j.total}};g=function(j,l){var m=j.groups,r,n,o=l.ration,k,p,s;h(j.keys,function(w,B){k=o*B;h(m[B],function(M,A){if(A.match){r=A.match.getAttribute("data-flex");n=A.match.getAttribute("data-specificity");if(!r||n<=A.flexSpecificity){A.match.setAttribute("data-flex",B);A.match.setAttribute("data-specificity",A.flexSpecificity);p=u(A.match,b.props.dim,q);s=Math.max(0,p+k);D(A.match,b.props.dim,s)}}})});if(c.orient==="horizontal"||c.orient==="inline-axis")qa(a,
+c,b)};i=R(c.children,d,t);if(i.total){c.hasFlex=q;e(i);e=f(i);g(i,e)}}},boxAlign:function(a,d,c){var b=this,e,f,g=ta(a);if(!H&&!g.flex&&(c.orient==="vertical"||c.orient==="block-axis")){Ra(a,b.anti.dim)||D(a,b.anti.dim,t);D(d,b.anti.dim,t)}e=a[b.anti.out];h(b.anti.pad,function(i,j){e-=u(a,j,q)});switch(c.align){case "start":break;case "end":h(d,function(i,j){f=e-j[b.anti.out];f-=u(j,b.anti.opp,q);D(j,b.anti.pos,f)});break;case "center":h(d,function(i,j){f=(e-j[b.anti.out])/2;D(j,b.anti.pos,f)});break;
+default:h(d,function(i,j){switch(j.nodeName.toLowerCase()){case "button":case "input":case "select":break;default:var l=0;h(b.anti.pad,function(m,r){l+=u(j,r,q);l+=u(a,r,q)});j.style[b.anti.dim]="100%";f=j[b.anti.out]-l;D(j,b.anti.dim,t);f=e;f-=u(j,b.anti.pos,q);h(b.anti.pad,function(m,r){f-=u(j,r,q)});f-=u(j,b.anti.opp,q);f=Math.max(0,f);D(j,b.anti.dim,f)}})}},boxPack:function(a,d,c){var b=this,e=0,f=0,g=0,i,j,l;l=d.length-1;h(d,function(r,n){e+=n[b.props.out];e+=u(n,b.props.pos,q);e+=u(n,b.props.opp,
+q)});f=u(d[0],b.props.pos,q);i=a[b.props.out]-e;h(b.props.pad,function(r,n){i-=u(a,n,q)});if(i<0)i=Math.max(0,i);switch(c.pack){case "end":D(d[0],b.props.pos,g+f+i);break;case "center":if(g)g/=2;D(d[0],b.props.pos,g+f+i/2);break;case "justify":f=Math.floor((g+i)/l);l=f*l-i;for(var m=d.length-1;m;){g=d[m];j=f;if(l){j++;l++}j=u(g,b.props.pos,q)+j;D(g,b.props.pos,j);m--}}if((c.pack==="end"||c.pack==="justify")&&(c.orient==="horizontal"||c.orient==="inline-axis"))qa(a,c,b);a.style.overflow=""}},setup:function(a,
+d,c){var b=this,e,f;if(!(!a||!d||!c))if(H&&H.partialSupport){e=R(c.children,d,t);f=ta(a);d=O(a,a.childNodes);b.properties.boxOrient.call(b,a,d,c);if(!e.total||!J(c.nested).length){if(c.align==="stretch"&&!H.boxAlignStretch&&(!f.nested||!f.flex))b.properties.boxAlign.call(b,a,d,c);c.pack==="justify"&&!H.boxPackJustify&&!e.total&&b.properties.boxPack.call(b,a,d,c)}}else H||h(b.properties,function(g,i){i.call(b,a,O(a,a.childNodes),c)})},trackDOM:function(a){Pa(this,a)},updateModel:function(a){var d=
+a.target,c=a.nodes;sa(c);if(a.flexMatrix||a.ordinalMatrix)a=Sa(a);this.setup(d,c,a);this.bubbleUp(d,a)},renderModel:function(a){var d=this,c=a.target,b=c.childNodes;if(!c.length&&!b)return false;a=Ta(a,this);d.updateModel(a);x.setTimeout(function(){d.trackDOM(a)},0);return d},bubbleUp:function(a,d){for(var c,b=d.target.parentNode;b;){if(c=y[b.FLX_DOM_ID]){sa(c.nodes);this.setup(c.target,c.nodes,c)}b=b.parentNode}}};z.updateInstance=function(a,d){var c;if(a)if(c=y[a.FLX_DOM_ID])c._instance.updateModel(c);
+else c=new z.box(d);else h(y,function(b,e){e._instance.updateModel(e)})};z.getInstance=function(a){return y[a.FLX_DOM_ID]};z.destroyInstance=function(a){var d;d=function(c){c.target.FLX_DOM_ID=t;c.target.style.cssText=v;h(c.children,function(b,e){e.match.style.cssText=v})};if(a)(a=y[a.FLX_DOM_ID])&&d(a);else{h(y,function(c,b){d(b)});y=[]}};z.flexboxSupport=function(){var a={},d,c=E.createElement("flxbox"),b;c.style.width=c.style.height="100px";c.innerHTML='<b style="margin: 0; padding: 0; display:block; width: 10px; height:50px"></b><b style="margin: 0; padding: 0; display:block; width: 10px; height:50px"></b><b style="margin: 0; padding: 0; display:block; width: 10px; height:50px"></b>';
+V(c,"display","box",t);V(c,"box-align","stretch",q);V(c,"box-pack","justify",q);E.body.appendChild(c);d=c.firstChild.offsetHeight;h({boxAlignStretch:function(){return d===100},boxPackJustify:function(){var e=0;h(c.childNodes,function(f,g){e+=g.offsetLeft});return e===135}},function(e,f){b=f();if(!b)a.partialSupport=q;a[e]=b});E.body.removeChild(c);return~c.style.display.indexOf("box")?a:I};z.init=function(){z.flexboxSupported=H=z.flexboxSupport();if((!H||H.partialSupport)&&J)va()};z.version=1;(function(a){Y||
+(J=ya());var d,c,b;h(X,function(e,f){if(x[e]&&!d&&f.m){d=eval(f.m.replace("*",e));c=f.c?eval(f.c.replace("*",e)):x;b=[];if(d&&c){f.p&&b.push(f.p);b.push(a);d.apply(c,b);return false}}});d||Z("load",a)})(z.init);return z}(this,document);

data/templates/drupal/sources/flexie/src/flexie.js

@@ -0,0 +1,1872 @@
+/*
+File: flexie.js
+
+About: Version
+	1.0
+
+Project: Flexie
+
+Description:
+	Legacy support for the CSS3 Flexible Box Model
+
+License:
+	The MIT License
+	
+	Copyright (c) 2010 Richard Herrera
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy
+	of this software and associated documentation files (the "Software"), to deal
+	in the Software without restriction, including without limitation the rights
+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	copies of the Software, and to permit persons to whom the Software is
+	furnished to do so, subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included in
+	all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+	THE SOFTWARE.
+*/
+
+/*
+Class: Flexie
+	Scoped to the Flexie Global Namespace
+*/
+
+/*jslint evil: true, regexp: false, plusplus: false */
+/*global window, document */
+
+var Flexie = (function (win, doc) {
+	
+	// Scope public properties
+	var FLX = {},
+	
+	    // Each Flexie-modified DOM node gets a unique identifier
+	    FLX_DOM_ID = 0,
+	    FLX_DOM_ATTR = "data-flexie-id",
+	    FLX_PARENT_ATTR = "data-flexie-parent",
+	    
+	    // Store support for flexbox
+	    SUPPORT,
+	    
+	    // Store reference to engine
+	    ENGINE,
+	
+	    ENGINES = {
+			"NW" : {
+				s : "*.Dom.select"
+			},
+			"DOMAssistant" : {
+				s : "*.$",
+				m : "*.DOMReady"
+			},
+			"Prototype" : {
+				s : "$$",
+				m : "document.observe",
+				p : "dom:loaded",
+				c : "document"
+			},
+			"YAHOO" : {
+				s : "*.util.Selector.query",
+				m : "*.util.Event.onDOMReady",
+				c : "*.util.Event"
+			},
+			"MooTools" : {
+				s : "$$",
+				m : "window.addEvent",
+				p : "domready"
+			},
+			"Sizzle" : {
+				s : "*"
+			},
+			"jQuery" : {
+				s : "*",
+				m : "*(document).ready"
+			},
+			"dojo" : {
+				s : "*.query",
+				m : "*.addOnLoad"
+			}
+		},
+	    
+	    // Store reference to library
+	    LIBRARY,
+	    
+	    // Regular Expressions
+	    PIXEL = /^-?\d+(?:px)?$/i,
+	    NUMBER = /^-?\d/,
+	    SIZES = /width|height|margin|padding|border/,
+	    MSIE = /(msie) ([\w.]+)/,
+	    WHITESPACE_CHARACTERS = /\t|\n|\r/g,
+	    RESTRICTIVE_PROPERTIES = /^max\-([a-z]+)/,
+	    PROTOCOL = /^https?:\/\//i,
+	    LEADINGTRIM = /^\s\s*/,
+	    TRAILINGTRIM = /\s\s*$/,
+	    ONLY_WHITESPACE = /^\s*$/,
+	    CSS_SELECTOR = /\s?(\#|\.|\[|\:(\:)?[^first\-(line|letter)|before|after]+)/g,
+		
+	    // String constants
+	    EMPTY_STRING = "",
+	    SPACE_STRING = " ",
+	    PLACEHOLDER_STRING = "$1",
+	    PADDING_RIGHT = "paddingRight",
+	    PADDING_BOTTOM = "paddingBottom",
+	    PADDING_LEFT = "paddingLeft",
+	    PADDING_TOP = "paddingTop",
+	    BORDER_RIGHT = "borderRightWidth",
+	    BORDER_BOTTOM = "borderBottomWidth",
+	    BORDER_LEFT = "borderLeftWidth",
+	    BORDER_TOP = "borderTopWidth",
+	    HORIZONTAL = "horizontal",
+	    VERTICAL = "vertical",
+	    INLINE_AXIS = "inline-axis",
+	    BLOCK_AXIS = "block-axis",
+	    INHERIT = "inherit",
+	    LEFT = "left",
+		
+	    END_MUSTACHE = "}",
+		
+	    PREFIXES = " -o- -moz- -ms- -webkit- -khtml- ".split(SPACE_STRING),
+		
+	    DEFAULTS = {
+			orient : HORIZONTAL,
+			align : "stretch",
+			direction : INHERIT,
+			pack : "start"
+	    },
+	    
+	    // Global reference objects
+	    FLEX_BOXES = [],
+	    POSSIBLE_FLEX_CHILDREN = [],
+	    DOM_ORDERED,
+	    
+	    RESIZE_LISTENER,
+	    
+	    // Minification optimizations
+	    TRUE = true,
+	    FALSE = false,
+	    NULL = null,
+	    UNDEFINED,
+	    
+	    // If IE, which version?
+	    BROWSER = {
+			IE : (function () {
+				var ie, ua = win.navigator.userAgent,
+				    match = (MSIE).exec(ua.toLowerCase());
+			
+				if (match) {
+					ie = parseInt(match[2], 10);
+				}
+			
+				return ie;
+			}())
+	    },
+	    
+	    /*
+	    selectivizr v1.0.0 - (c) Keith Clark, freely distributable under the terms 
+	    of the MIT license.
+        
+	    selectivizr.com
+	    */
+	    selectivizrEngine;
+	
+	function trim (string) {
+		if (string) {
+			string = string.replace(LEADINGTRIM, EMPTY_STRING).replace(TRAILINGTRIM, EMPTY_STRING);
+		}
+		
+		return string;
+	}
+	
+	// Via jQuery 1.4.3
+	// http://github.com/jquery/jquery/blob/master/src/core.js#L593
+	function forEach(object, callback) {
+		var name, i = 0, value,
+			length = object ? object.length : UNDEFINED,
+			isObj = length === UNDEFINED;
+
+		if (isObj) {
+			for (name in object) {
+				if (object.hasOwnProperty(name)) {
+					if (callback.call(object[name], name, object[name]) === FALSE) {
+						break;
+					}
+				}
+			}
+		} else {
+			for (value = object[0]; i < length && callback.call(value, i, value) !== FALSE; value = object[++i]) {
+				continue;
+			}
+		}
+	}
+	
+	// --[ determineSelectorMethod() ]--------------------------------------
+	// walks through the engines object testing for an suitable
+	// selector engine.
+	
+	// Moving outside Selectivizr scope because detection is needed before running selectivizrEngine
+	function determineSelectorMethod() {
+		// compatiable selector engines in order of CSS3 support
+		var engines = ENGINES, method;
+		
+		forEach(engines, function (engine, obj) {
+			if (win[engine] && !method) {
+				method = eval(obj.s.replace("*", engine));
+				
+				if (method) {
+					ENGINE = engine;
+					return false;
+				}
+			}
+		});
+		
+		return method;
+	}
+	
+	// Event handler for onload/onresize events
+	function addEvent(type, func) {
+		type = "on" + type;
+		var oldevent = win[type];
+
+		if (typeof win[type] !== "function") {
+			win[type] = func;
+		} else {
+			win[type] = function () {
+				if (oldevent) {
+					oldevent();
+				}
+				func();
+			};
+		}
+	}
+	
+	function attachLoadMethod(handler) {
+		if (!ENGINE) {
+			LIBRARY = determineSelectorMethod();
+		}
+		
+		// compatiable selector engines in order of CSS3 support
+		var engines = ENGINES,
+		    method, caller, args;
+		
+		forEach(engines, function (engine, obj) {
+			if (win[engine] && !method && obj.m) {
+				method = eval(obj.m.replace("*", engine));
+				caller = obj.c ? eval(obj.c.replace("*", engine)) : win;
+				args = [];
+				
+				if (method && caller) {
+					if (obj.p) {
+						args.push(obj.p);
+					}
+					args.push(handler);
+					method.apply(caller, args);
+					return false;
+				}
+			}
+		});
+		
+		if (!method) {
+			addEvent("load", handler);
+		}
+	}
+	
+	function buildSelector (node) {
+		var selector = node.nodeName.toLowerCase();
+		
+		if (node.id) {
+			selector += "#" + node.id;
+		} else if (node.FLX_DOM_ID) {
+			selector += "[" + FLX_DOM_ATTR + "='" + node.FLX_DOM_ID + "']";
+		}
+		
+		return selector;
+	}
+	
+	function setFlexieId (node) {
+		if (!node.FLX_DOM_ID) {
+			FLX_DOM_ID = (FLX_DOM_ID + 1);
+			
+			node.FLX_DOM_ID = FLX_DOM_ID;
+			node.setAttribute(FLX_DOM_ATTR, node.FLX_DOM_ID);
+		}
+	}
+	
+	function buildSelectorTree(text) {
+		var rules = [], ruletext, rule,
+		    match, selector, proptext, splitprop, properties;
+		
+		// Tabs, Returns
+		text = text.replace(WHITESPACE_CHARACTERS, EMPTY_STRING);
+		
+		// Leading / Trailing Whitespace
+		text = text.replace(/\s?(\{|\:|\})\s?/g, PLACEHOLDER_STRING);
+		
+		ruletext = text.split(END_MUSTACHE);
+		
+		forEach(ruletext, function (i, text) {
+			if (text) {
+				rule = [text, END_MUSTACHE].join(EMPTY_STRING);
+				
+				match = (/(.*)\{(.*)\}/).exec(rule);
+				
+				if (match && match[2]) {
+					selector = match[1];
+					proptext = match[2].split(";");
+					properties = [];
+					
+					forEach(proptext, function (i, x) {
+						splitprop = x.split(":");
+						
+						if (splitprop.length && splitprop[1]) {
+							properties.push({
+								property : splitprop[0],
+								value : splitprop[1]
+							});
+						}
+					});
+					
+					if (selector && properties.length) {
+						rules.push({
+							selector : selector,
+							properties : properties
+						});
+					}
+				}
+			}
+		});
+		
+		return rules;
+	}
+	
+	function findFlexboxElements(rules) {
+		var selectors, properties,
+		    property, value, shortProp,
+		    selectorSplit = /\s?,\s?/,
+		    createUniqueObject, addRules,
+		    uniqueChildren = {}, uniqueBoxes = {};
+		
+		createUniqueObject = function (selector, rules, prop, value) {
+			var unique = {
+				selector : trim(selector),
+				properties : []
+			};
+
+			forEach(rules.properties, function (i, prop) {
+				unique.properties.push({
+					property : trim(prop.property),
+					value : trim(prop.value)
+				});
+			});
+			
+			if (prop && value) {
+				unique[prop] = value;
+			}
+			
+			return unique;
+		};
+		
+		addRules = function (selector, rules, prop, value) {
+			var box = (prop && value) ? uniqueChildren[selector] : uniqueBoxes[selector],
+			    exists;
+			
+			if (box) {
+				forEach(rules.properties, function (i, rule) {
+					forEach(box.properties, function (j, x) {
+						if (rule.property === x.property) {
+							exists = j;
+							return false;
+						}
+					});
+					
+					if (exists) {
+						box.properties[exists] = rule;
+					} else {
+						box.properties.push(rule);
+					}
+				});
+				
+				if (prop && value) {
+					box[prop] = value;
+				}
+			} else {
+				if (prop && value) {
+					uniqueChildren[selector] = createUniqueObject(selector, rules, prop, value);
+				} else {
+					uniqueBoxes[selector] = createUniqueObject(selector, rules, NULL, NULL);
+				}
+			}
+		};
+		
+		forEach(rules, function (i, rule) {
+			selectors = trim(rule.selector).replace(selectorSplit, ",").split(selectorSplit);
+			
+			forEach(selectors, function (i, selector) {
+				selector = trim(selector);
+				properties = rule.properties;
+
+				forEach(properties, function (i, prop) {
+					property = trim(prop.property);
+					value = trim(prop.value);
+
+					if (property) {
+						shortProp = property.replace("box-", EMPTY_STRING);
+
+						switch (shortProp) {
+						case "display" :
+							if (value === "box") {
+								addRules(selector, rule, NULL, NULL);
+							}
+							break;
+
+						case "orient" :
+						case "align" :
+						case "direction" :
+						case "pack" :
+							addRules(selector, rule, NULL, NULL);
+							break;
+
+						case "flex" :
+						case "flex-group" :
+						case "ordinal-group" :
+							addRules(selector, rule, shortProp, value);
+							break;
+						}
+					}
+				});
+			});
+		});
+		
+		forEach(uniqueBoxes, function (key, box) {
+			FLEX_BOXES.push(box);
+		});
+		
+		forEach(uniqueChildren, function (key, child) {
+			POSSIBLE_FLEX_CHILDREN.push(child);
+		});
+		
+		return {
+			boxes : FLEX_BOXES,
+			children : POSSIBLE_FLEX_CHILDREN
+		};
+	}
+	
+	function matchFlexChildren(parent, lib, possibleChildren) {
+		var caller, unique, matches = [];
+		
+		forEach(possibleChildren, function (i, child) {
+			if (child.selector) {
+				caller = lib(child.selector);
+				caller = caller[0] ? caller : [caller];
+
+				if (caller[0]) {
+					forEach(caller, function (i, node) {
+						switch (node.nodeName.toLowerCase()) {
+						case "script" :
+						case "style" :
+						case "link" :
+							break;
+
+						default :
+							if (node.parentNode === parent) {
+								// Flag each unique node with FLX_DOM_ID
+								setFlexieId(node);
+
+								unique = {};
+
+								forEach(child, function (key) {
+									unique[key] = child[key];
+								});
+
+								unique.match = node;
+								matches.push(unique);
+							}
+							break;
+						}
+					});
+				}
+			} else {
+				// Flag each unique node with FLX_DOM_ID
+				setFlexieId(child);
+				
+				matches.push({
+					match : child,
+					selector : buildSelector(child)
+				});
+			}
+		});
+		
+		return matches;
+	}
+	
+	function getParams(params) {
+		forEach(params, function (key, value) {
+			params[key] = value || DEFAULTS[key];
+		});
+		
+		return params;
+	}
+	
+	function buildFlexieCall(flexers) {
+		var selector, properties, property, value, shortProp,
+		    display, orient, align, direction, pack,
+		    lib, caller, children,
+		    box, params, flexboxes = {},
+		    match, childMatch, nestedFlexboxes,
+		    flexieParentSelector = "[" + FLX_PARENT_ATTR + "]";
+		
+		// No boxflex? No dice.
+		if (!flexers) {
+			return;
+		}
+		
+		forEach(flexers.boxes, function (i, flex) {
+			flex.selector = trim(flex.selector);
+			
+			selector = flex.selector;
+			properties = flex.properties;
+			
+			display = orient = align = direction = pack = NULL;
+			
+			forEach(properties, function (i, prop) {
+				
+				property = trim(prop.property);
+				value = trim(prop.value);
+				
+				if (property) {
+					shortProp = property.replace("box-", EMPTY_STRING);
+					
+					switch (shortProp) {
+					case "display" :
+						if (value === "box") {
+							display = value;
+						}
+						break;
+						
+					case "orient" :
+						orient = value;
+						break;
+
+					case "align" :
+						align = value;
+						break;
+
+					case "direction" :
+						direction = value;
+						break;
+
+					case "pack" :
+						pack = value;
+						break;
+					}
+				}
+			});
+			
+			// Determine library
+			lib = LIBRARY;
+			
+			// Call it.
+			caller = lib(flex.selector);
+			
+			// In an array?
+			caller = caller[0] ? caller : [caller];
+			
+			forEach(caller, function (i, target) {
+				// If is DOM object
+				if (target.nodeType) {
+					// Flag each unique node with FLX_DOM_ID
+					setFlexieId(target);
+					
+					// Find possible child node matches
+					children = matchFlexChildren(target, lib, flexers.children);
+					
+					// Find any nested flexbox elements
+					nestedFlexboxes = selector + " " + flexieParentSelector;
+
+					// Make sure there is some value associated with box properties
+					params = {
+						target : target,
+						selector : selector,
+						properties : properties,
+						children : children,
+						display : display,
+						orient : orient,
+						align : align,
+						direction: direction,
+						pack : pack,
+						nested : nestedFlexboxes
+					};
+
+					match = flexboxes[target.FLX_DOM_ID];
+
+					if (match) {
+						forEach(params, function (key, value) {
+							switch (key) {
+							case "selector" :
+								if (value && !(new RegExp(value).test(match[key]))) {
+									match[key] += ", " + value;
+								}
+								break;
+							
+							case "children" :
+								forEach(params[key], function (k, child) {
+									childMatch = FALSE;
+									
+									forEach(match[key], function (key, existing) {
+										if (child.match.FLX_DOM_ID === existing.match.FLX_DOM_ID) {
+											childMatch = TRUE;
+										}
+									});
+									
+									if (!childMatch) {
+										match[key].push(child);
+									}
+								});
+								break;
+								
+							default :
+								if (value) {
+									match[key] = value;
+								}
+								break;
+							}
+						});
+					} else {
+						flexboxes[target.FLX_DOM_ID] = getParams(params);
+						flexboxes[target.FLX_DOM_ID].target.setAttribute(FLX_PARENT_ATTR, TRUE);
+					}
+				}
+			});
+		});
+		
+		DOM_ORDERED = LIBRARY(flexieParentSelector);
+		FLEX_BOXES = {};
+		
+		forEach(DOM_ORDERED, function (i, target) {
+			FLEX_BOXES[target.FLX_DOM_ID] = flexboxes[target.FLX_DOM_ID];
+		});
+		
+		// Loop through each match, initialize constructor
+		forEach(FLEX_BOXES, function (key, flex) {
+			// One final check to ensure each flexbox has a display property
+			if (flex.display === "box") {
+				// Constructor
+				box = new FLX.box(flex);
+			}
+		});
+	}
+	
+	function calcPx(element, props, dir) {
+		var dim = dir.replace(dir.charAt(0), dir.charAt(0).toUpperCase()),
+		    value = element["offset" + dim] || 0;
+		
+		if (value) {
+			forEach(props, function (i, prop) {
+				prop = parseFloat(element.currentStyle[prop]);
+				if (!isNaN(prop)) {
+					value -= prop;
+				}
+			});
+		}
+		
+		return value;
+	}
+	
+	function getTrueValue(element, name) {
+		var left, rsLeft,
+		    ret = element.currentStyle && element.currentStyle[name],
+		    style = element.style;
+
+		if (!PIXEL.test(ret) && NUMBER.test(ret)) {
+
+			// Remember the original values
+			left = style.left;
+			rsLeft = element.runtimeStyle.left;
+
+			// Put in the new values to get a computed value out
+			element.runtimeStyle.left = element.currentStyle.left;
+			style.left = ret || 0;
+			ret = style.pixelLeft + "px";
+
+			// Revert the changed values
+			style.left = left || 0;
+			element.runtimeStyle.left = rsLeft;
+		}
+
+		return ret;
+	}
+	
+	function unAuto(element, prop, name) {
+		var props;
+		
+		switch (name) {
+		case "width" :
+			props = [PADDING_LEFT, PADDING_RIGHT, BORDER_LEFT, BORDER_RIGHT];
+			prop = calcPx(element, props, name);
+			break;
+
+		case "height" :
+			props = [PADDING_TOP, PADDING_BOTTOM, BORDER_TOP, BORDER_BOTTOM];
+			prop = calcPx(element, props, name);
+			break;
+
+		default :
+			prop = getTrueValue(element, name);
+			break;
+		}
+
+		return prop;
+	}
+	
+	function getPixelValue(element, prop, name) {
+		if (PIXEL.test(prop)) {
+			return prop;
+		}
+		
+		// if property is auto, do some messy appending
+		if (prop === "auto" || prop === "medium") {
+			prop = unAuto(element, prop, name);
+		} else {
+			prop = getTrueValue(element, name);
+		}
+		
+		return prop;
+	}
+	
+	function getComputedStyle(element, property, returnAsInt) {
+		var value;
+		
+		if (win.getComputedStyle) {
+			value = win.getComputedStyle(element, NULL)[property];
+		} else {
+			if (SIZES.test(property)) {
+				value = getPixelValue(element, (element && element.currentStyle) ? element.currentStyle[property] : 0, property);
+			} else {
+				value = element.currentStyle[property];
+			}
+		}
+		
+		if (returnAsInt) {
+			value = parseInt(value, 10);
+			
+			if (isNaN(value)) {
+				value = 0;
+			}
+		}
+		
+		return value;
+	}
+	
+	function clientWidth(element) {
+		return element.innerWidth || element.clientWidth;
+	}
+	
+	function clientHeight(element) {
+		return element.innerHeight || element.clientHeight;
+	}
+	
+	function appendProperty(target, prop, value, prefixName) {
+		var cssText = [];
+
+		forEach(PREFIXES, function (i, prefix) {
+			cssText.push((prefixName ? prefix : EMPTY_STRING) + prop + ":" + (!prefixName ? prefix : EMPTY_STRING) + value);
+		});
+
+		target.style.cssText += cssText.join(";");
+		return target;
+	}
+	
+	function appendPixelValue(target, prop, value) {
+		var targets = target && target[0] ? target : [target];
+		
+		forEach(targets, function (i, target) {
+			if (target && target.style) {
+				target.style[prop] = (value ? (value + "px") : EMPTY_STRING);
+			}
+		});
+	}
+	
+	function calculateSpecificity (selector) {
+		var selectorGrid, matrix, total;
+		
+		selectorGrid = selector.replace(CSS_SELECTOR, function (e, f) {
+			return "%" + f;
+		}).replace(/\s|\>|\+|\~/g, "%").split(/%/g);
+		
+		matrix = {
+			_id : 100,
+			_class : 10,
+			_tag : 1
+		};
+		
+		// Start with rule index position
+		total = 0;
+		
+		// Add each selector value to total.
+		forEach(selectorGrid, function (i, chunk) {
+			if ((/#/).test(chunk)) {
+				total += matrix._id;
+			} else if ((/\.|\[|\:/).test(chunk)) {
+				total += matrix._class;
+			} else if ((/[a-zA-Z]+/).test(chunk)) {
+				total += matrix._tag;
+			}
+		});
+		
+		return total;
+	}
+	
+	function filterDuplicates (matches, children, type) {
+		var filteredMatches = [], exists,
+		    spec = (type ? "ordinal" : "flex") + "Specificity";
+		
+		forEach(matches, function (i, x) {
+			if ((!type && x.flex) || (type && x["ordinal-group"])) {
+				x[spec] = x[spec] || calculateSpecificity(x.selector);
+				
+				exists = FALSE;
+			
+				forEach(filteredMatches, function (j, f) {
+					if (f.match === x.match) {
+						if (f[spec] < x[spec]) {
+							filteredMatches[j] = x;
+						}
+					
+						exists = TRUE;
+						return FALSE;
+					}
+				});
+			
+				if (!exists) {
+					filteredMatches.push(x);
+				}
+			}
+		});
+		
+		return filteredMatches;
+	}
+	
+	function createMatchMatrix(matches, children, type) {
+		var groups = {}, keys = [], totalRatio = 0,
+		    group, order = "ordinal-group",
+		    BoxOrdinalAttr = "data-" + order;
+		
+		// Filter dupes
+		matches = filterDuplicates(matches, children, type);
+
+		forEach(children, function (i, kid) {
+			forEach(matches, function (j, x) {
+				if (type) {
+					// If no value declared, it's the default.
+					group = x[order] || "1";
+					
+					if (x.match === kid) {
+						x.match.setAttribute(BoxOrdinalAttr, group);
+						
+						groups[group] = groups[group] || [];
+						groups[group].push(x);
+					}
+				} else {
+					// If no value declared, it's the default.
+					group = x.flex || "0";
+					
+					if (x.match === kid && (!x[group] || (x[group] && parseInt(x[group], 10) <= 1))) {
+						totalRatio += parseInt(group, 10);
+
+						groups[group] = groups[group] || [];
+						groups[group].push(x);
+					}
+				}
+			});
+			
+			if (type && !kid.getAttribute(BoxOrdinalAttr)) {
+				group = "1";
+				kid.setAttribute(BoxOrdinalAttr, group);
+				
+				groups[group] = groups[group] || [];
+				groups[group].push({
+					match : kid
+				});
+			}
+		});
+
+		forEach(groups, function (key) {
+			keys.push(key);
+		});
+
+		keys.sort(function (a, b) {
+			return b - a;
+		});
+
+		return {
+			keys : keys,
+			groups : groups,
+			total : totalRatio
+		};
+	}
+	
+	function floatDropFix(target, params, instance) {
+		// Float drop fix
+		// Test offset values. If different, let's bring the widow back
+		var offsetProp = "offsetTop",
+		    children = params.nodes,
+		    calcOffset, val = true;
+		
+		calcOffset = function (kid) {
+			return kid[offsetProp] - getComputedStyle(kid, instance.anti.pos, TRUE);
+		};
+		
+		while (val && calcOffset(children[0]) !== calcOffset(children[children.length - 1])) {
+			forEach(children, function (i, kid) {
+				if (!params.hasFlex || kid.getAttribute("data-flex")) {
+					val = Math.max(0, getComputedStyle(kid, instance.props.dim, TRUE) - 1);
+					kid.style[instance.props.dim] = val;
+				}
+			});
+		}
+	}
+	
+	function attachResizeListener(construct, params) {
+		if (!RESIZE_LISTENER) {
+			var storedWidth, storedHeight,
+			    currentWidth, currentHeight,
+			    docBody = doc.body,
+			    docEl = doc.documentElement,
+			    innerWidth = "innerWidth", innerHeight = "innerHeight",
+			    clientWidth = "clientWidth", clientHeight = "clientHeight";
+			
+			addEvent("resize", function () {
+				currentWidth = win[innerWidth] || docEl[innerWidth] || docEl[clientWidth] || docBody[clientWidth];
+				currentHeight = win[innerHeight] || docEl[innerHeight] || docEl[clientHeight] || docBody[clientHeight];
+				
+				if (storedWidth !== currentWidth || storedHeight !== currentHeight) {
+					FLX.updateInstance(NULL, NULL);
+					
+					storedWidth = currentWidth;
+					storedHeight = currentHeight;
+				}
+			});
+			
+			RESIZE_LISTENER = TRUE;
+		}
+	}
+	
+	function cleanPositioningProperties (children) {
+		var w, h;
+		
+		forEach(children, function (i, kid) {
+			w = kid.style.width;
+			h = kid.style.height;
+			
+			kid.style.cssText = EMPTY_STRING;
+			
+			kid.style.width = w;
+			kid.style.height = h;
+		});
+	}
+	
+	function sanitizeChildren (target, nodes) {
+		var children = [], node, i, j;
+		
+		for (i = 0, j = nodes.length; i < j; i++) {
+			node = nodes[i];
+			
+			if (node) {
+				switch (node.nodeName.toLowerCase()) {
+				case "script" :
+				case "style" :
+				case "link" :
+					break;
+
+				default :
+					if (node.nodeType === 1) {
+						children.push(node);
+					} else if ((node.nodeType === 3) && (node.isElementContentWhitespace || (ONLY_WHITESPACE).test(node.data))) {
+						target.removeChild(node);
+						i--;
+					}
+					break;
+				}
+			}
+		}
+		
+		return children;
+	}
+	
+	function parentFlex (target) {
+		var totalFlex = 0,
+		    parent = target.parentNode,
+		    obj,
+		    matrix,
+		    isNested;
+		
+		while (parent.FLX_DOM_ID) {
+			obj = FLEX_BOXES[parent.FLX_DOM_ID];
+			matrix = createMatchMatrix(obj.children, sanitizeChildren(parent, parent.childNodes), NULL);
+			
+			totalFlex += matrix.total;
+			isNested = TRUE;
+			
+			parent = parent.parentNode;
+		}
+		
+		return {
+			nested : isNested,
+			flex : totalFlex
+		};
+	}
+	
+	function dimensionValues (target, prop) {
+		var parent = target.parentNode,
+		    obj,
+		    dimension;
+		
+		if (parent.FLX_DOM_ID) {
+			obj = FLEX_BOXES[parent.FLX_DOM_ID];
+			
+			forEach(obj.properties, function (i, rule) {
+				if ((new RegExp(prop)).test(rule.property)) {
+					dimension = TRUE;
+					return FALSE;
+				}
+			});
+		}
+		
+		return dimension;
+	}
+	
+	function updateChildValues (params) {
+		if (params.flexMatrix) {
+			forEach(params.children, function (i, x) {
+				x.flex = params.flexMatrix[i];
+			});
+		}
+		
+		if (params.ordinalMatrix) {
+			forEach(params.children, function (i, x) {
+				x["ordinal-group"] = params.ordinalMatrix[i];
+			});
+		}
+		
+		return params;
+	}
+	
+	function ensureStructuralIntegrity (params, instance) {
+		var target = params.target;
+		
+		if (!target.FLX_DOM_ID) {
+			target.FLX_DOM_ID = target.FLX_DOM_ID || (++FLX_DOM_ID);
+		}
+		
+		if (!params.nodes) {
+			params.nodes = sanitizeChildren(target, target.childNodes);
+		}
+		
+		if (!params.selector) {
+			params.selector = buildSelector(target);
+			target.setAttribute(FLX_PARENT_ATTR, TRUE);
+		}
+		
+		if (!params.properties) {
+			params.properties = [];
+		}
+		
+		if (!params.children) {
+			params.children = matchFlexChildren(target, LIBRARY, sanitizeChildren(target, target.childNodes));
+		}
+		
+		if (!params.nested) {
+			params.nested = params.selector + " [" + FLX_PARENT_ATTR + "]";
+		}
+		
+		params.target = target;
+		params._instance = instance;
+		
+		return params;
+	}
+	
+	selectivizrEngine = (function () {
+		var RE_COMMENT = /(\/\*[^*]*\*+([^\/][^*]*\*+)*\/)\s*/g,
+		    RE_IMPORT = /@import\s*(?:url\(\s*?)?(["'])?(.*?)\1\s*\)?[\w\W]*?;/g,
+		    RE_ASSET_URL = /\surl\((["'])?([^"')]+)\1\)/g,
+		    RE_SELECTOR_GROUP = /(^|\})\s*([^\{]*?[\[:][^\{]+)/g,
+			
+		    // Whitespace normalization regexp's
+		    RE_TIDY_TRAILING_WHITESPACE = /([(\[+~])\s+/g,
+		    RE_TIDY_LEADING_WHITESPACE = /\s+([)\]+~])/g,
+		    RE_TIDY_CONSECUTIVE_WHITESPACE = /\s+/g,
+		    RE_TIDY_TRIM_WHITESPACE = /^\s*((?:[\S\s]*\S)?)\s*$/;
+
+		// --[ trim() ]---------------------------------------------------------
+		// removes leading, trailing whitespace from a string
+		function trim(text) {
+			return text.replace(RE_TIDY_TRIM_WHITESPACE, PLACEHOLDER_STRING);
+		}
+
+		// --[ normalizeWhitespace() ]------------------------------------------
+		// removes leading, trailing and consecutive whitespace from a string
+		function normalizeWhitespace(text) {
+			return trim(text).replace(RE_TIDY_CONSECUTIVE_WHITESPACE, SPACE_STRING);
+		}
+
+		// --[ normalizeSelectorWhitespace() ]----------------------------------
+		// tidys whitespace around selector brackets and combinators
+		function normalizeSelectorWhitespace(selectorText) {
+			return normalizeWhitespace(selectorText.replace(RE_TIDY_TRAILING_WHITESPACE, PLACEHOLDER_STRING).replace(RE_TIDY_LEADING_WHITESPACE, PLACEHOLDER_STRING));
+		}
+
+		// --[ patchStyleSheet() ]----------------------------------------------
+		// Scans the passed cssText for selectors that require emulation and
+		// creates one or more patches for each matched selector.
+		function patchStyleSheet(cssText) {
+			return cssText.replace(RE_SELECTOR_GROUP, function (m, prefix, selectorText) {
+				var selectorGroups, selector;
+				
+				selectorGroups = selectorText.split(",");
+				
+				forEach(selectorGroups, function (i, group) {
+					selector = normalizeSelectorWhitespace(group) + SPACE_STRING;
+				});
+				
+				return prefix + selectorGroups.join(",");
+			});
+		}
+		
+		// --[ getXHRObject() ]-------------------------------------------------
+		function getXHRObject() {
+			if (win.XMLHttpRequest) {
+				return new win.XMLHttpRequest();
+			}
+			
+			try	{ 
+				return new win.ActiveXObject("Microsoft.XMLHTTP");
+			} catch (e) { 
+				return NULL;
+			}
+		}
+		
+		// --[ loadStyleSheet() ]-----------------------------------------------
+		function loadStyleSheet(url) {
+			var xhr = getXHRObject();
+			
+			xhr.open("GET", url, FALSE);
+			xhr.send();
+			return (xhr.status === 200) ? xhr.responseText : EMPTY_STRING;	
+		}
+		
+		// --[ resolveUrl() ]---------------------------------------------------
+		// Converts a URL fragment to a fully qualified URL using the specified
+		// context URL. Returns null if same-origin policy is broken
+		function resolveUrl(url, contextUrl) {
+			
+			// IE9 returns a false positive sometimes(?)
+			if (!url) {
+				return;
+			}
+			
+			function getProtocolAndHost(url) {
+				return url.substring(0, url.indexOf("/", 8));
+			}
+
+			// absolute path
+			if (PROTOCOL.test(url)) {
+				return getProtocolAndHost(contextUrl) === getProtocolAndHost(url) ? url : NULL;
+			}
+
+			// root-relative path
+			if (url.charAt(0) === "/")	{
+				return getProtocolAndHost(contextUrl) + url;
+			}
+
+			// relative path
+			var contextUrlPath = contextUrl.split("?")[0]; // ignore query string in the contextUrl
+			if (url.charAt(0) !== "?" && contextUrlPath.charAt(contextUrlPath.length - 1) !== "/") {
+				contextUrlPath = contextUrlPath.substring(0, contextUrlPath.lastIndexOf("/") + 1);
+			}
+
+			return contextUrlPath + url;
+		}
+		
+		// --[ parseStyleSheet() ]----------------------------------------------
+		// Downloads the stylesheet specified by the URL, removes it's comments
+		// and recursivly replaces @import rules with their contents, ultimately
+		// returning the full cssText.
+		function parseStyleSheet(url) {
+			if (url) {
+				return loadStyleSheet(url).replace(RE_COMMENT, EMPTY_STRING).replace(RE_IMPORT, function( match, quoteChar, importUrl ) {
+					return parseStyleSheet(resolveUrl(importUrl, url));
+				}).replace(RE_ASSET_URL, function( match, quoteChar, assetUrl ) {
+					quoteChar = quoteChar || EMPTY_STRING;
+					return " url(" + quoteChar + resolveUrl(assetUrl, url) + quoteChar + ") ";
+				});
+			}
+			return EMPTY_STRING;
+		}
+		
+		// --[ init() ]---------------------------------------------------------
+		return function () {
+			// honour the <base> tag
+			var url, stylesheet, i, j,
+			    baseTags = doc.getElementsByTagName("BASE"),
+			    baseUrl = (baseTags.length > 0) ? baseTags[0].href : doc.location.href,
+			    cssText, tree, flexers;
+			
+			for (i = 0, j = doc.styleSheets.length; i < j; i++) {
+				stylesheet = doc.styleSheets[i];
+				
+				if (stylesheet && stylesheet.href !== NULL) {
+					url = resolveUrl(stylesheet.href, baseUrl);
+					
+					if (url) {
+						cssText = patchStyleSheet(parseStyleSheet(url));
+						tree = buildSelectorTree(cssText);
+						flexers = findFlexboxElements(tree);
+					}
+				}
+			}
+			
+			buildFlexieCall(flexers);
+		};
+	}());
+	
+	// Flexie box constructor
+	FLX.box = function (params) {
+		return this.renderModel(params);
+	};
+	
+	FLX.box.prototype = {
+		properties : {
+			boxModel : function (target, children, params) {
+				var selector, stylesheet, paddingFix, generatedRules;
+
+				target.style.display = "block";
+				
+				if (BROWSER.IE === 8) {
+					target.style.overflow = "hidden";
+				}
+
+				// We'll be using floats, so the easiest way to retain layout
+				// is the dreaded clear fix:
+				if (!params.cleared) {
+					selectors = params.selector.split(/\s?,\s?/);
+					stylesheet = doc.styleSheets;
+					stylesheet = stylesheet[stylesheet.length - 1];
+					paddingFix = "padding-top:" + (getComputedStyle(target, PADDING_TOP, NULL) || "0.1px;");
+				
+					generatedRules = [
+						"content: '.'",
+						"display: block",
+						"height: 0",
+						"overflow: hidden"
+					].join(";");
+				
+					forEach(selectors, function (i, selector) {
+						if (stylesheet.addRule) {
+							if (BROWSER.IE < 8) {
+								target.style.zoom = "1";
+
+								if (BROWSER.IE === 6) {
+									stylesheet.addRule(selector.replace(/\>|\+|\~/g, ""), paddingFix + "zoom:1;", 0);
+								} else if (BROWSER.IE === 7) {
+									stylesheet.addRule(selector, paddingFix + "display:inline-block;", 0);
+								}
+							} else {
+								stylesheet.addRule(selector, paddingFix, 0);
+								stylesheet.addRule(selector + ":before", generatedRules, 0);
+								stylesheet.addRule(selector + ":after", generatedRules + ";clear:both;", 0);
+							}
+						} else if (stylesheet.insertRule) {
+							stylesheet.insertRule(selector + "{" + paddingFix + "}", 0);
+							stylesheet.insertRule(selector + ":after{" + generatedRules + ";clear:both;}", 0);
+						}
+					});
+					
+					params.cleared = TRUE;
+				}
+			},
+			
+			boxDirection : function (target, children, params) {
+				var nestedSelector, nested;
+				
+				if ((params.direction === "reverse" && !params.reversed) || (params.direction === "normal" && params.reversed)) {
+					children = children.reverse();
+
+					forEach(children, function (i, kid) {
+						target.appendChild(kid);
+					});
+					
+					// box-direction is inheritable.
+					// We need to see if there are any nested flexbox elements
+					nestedSelector = LIBRARY(params.nested);
+					
+					forEach(nestedSelector, function (i, node) {
+						nested = FLEX_BOXES[node.FLX_DOM_ID];
+						
+						if (nested && nested.direction === INHERIT) {
+							nested.direction = params.direction;
+						}
+					});
+
+					params.reversed = !params.reversed;
+				}
+			},
+			
+			boxOrient : function (target, children, params) {
+				var self = this, wide, high;
+
+				wide = {
+					pos : "marginLeft",
+					opp : "marginRight",
+					dim : "width",
+					out : "offsetWidth",
+					func : clientWidth,
+					pad : [PADDING_LEFT, PADDING_RIGHT, BORDER_LEFT, BORDER_RIGHT]
+				};
+
+				high = {
+					pos : "marginTop",
+					opp : "marginBottom",
+					dim : "height",
+					out : "offsetHeight",
+					func : clientHeight,
+					pad : [PADDING_TOP, PADDING_BOTTOM, BORDER_TOP, BORDER_BOTTOM]
+				};
+
+				if (!SUPPORT) {
+					forEach(children, function (i, kid) {
+						kid.style[(BROWSER.IE >= 9) ? "cssFloat" : "styleFloat"] = LEFT;
+
+						if (params.orient === VERTICAL || params.orient === BLOCK_AXIS) {
+							kid.style.clear = LEFT;
+						}
+						
+						if (BROWSER.IE === 6) {
+							kid.style.display = "inline";
+						}
+					});
+				}
+
+				switch (params.orient) {
+				case VERTICAL :
+				case BLOCK_AXIS:
+					self.props = high;
+					self.anti = wide;
+					break;
+				
+				default :
+					self.props = wide;
+					self.anti = high;
+					break;
+				}
+			},
+			
+			boxOrdinalGroup : function (target, children, params) {
+				var organizeChildren,
+				    matrix;
+
+				if (!children.length) {
+					return;
+				}
+				
+				organizeChildren = function (matrix) {
+					var keys = matrix.keys;
+					
+					forEach(params.reversed ? keys : keys.reverse(), function (i, key) {
+						forEach(children, function (i, kid) {
+							if (key === kid.getAttribute("data-ordinal-group")) {
+								target.appendChild(kid);
+							}
+						});
+					});
+				};
+
+				matrix = createMatchMatrix(params.children, children, TRUE);
+
+				if (matrix.keys.length > 1) {
+					organizeChildren(matrix);
+				}
+			},
+			
+			boxFlex : function (target, children, params) {
+				var self = this,
+				    testForRestrictiveProperties,
+				    findTotalWhitespace,
+				    distributeRatio,
+				    matrix,
+				    restrict,
+				    whitespace,
+				    distro;
+
+				if (!children.length) {
+					return;
+				}
+				
+				testForRestrictiveProperties = function (matrix) {
+					var flexers = matrix.groups,
+					    keys = matrix.keys,
+					    max;
+					
+					forEach(keys, function (i, key) {
+						forEach(flexers[key], function (i, x) {
+							max = NULL;
+							
+							forEach(x.properties, function (i, rule) {
+								if ((RESTRICTIVE_PROPERTIES).test(rule.property)) {
+									max = parseFloat(rule.value);
+								}
+							});
+							
+							if (!max || x.match[self.props.out] > max) {
+								appendPixelValue(x.match, self.props.pos, NULL);
+							}
+							
+						});
+					});
+				};
+
+				findTotalWhitespace = function (matrix) {
+					var groupDimension = 0,
+					    whitespace,
+					    ration;
+
+					forEach(children, function (i, kid) {
+						groupDimension += getComputedStyle(kid, self.props.dim, TRUE);
+						
+						forEach(self.props.pad, function (i, pad) {
+							groupDimension += getComputedStyle(kid, pad, TRUE);
+						});
+						
+						groupDimension += getComputedStyle(kid, self.props.pos, TRUE);
+						groupDimension += getComputedStyle(kid, self.props.opp, TRUE);
+					});
+
+					whitespace = target[self.props.out] - groupDimension;
+					
+					forEach(self.props.pad, function (i, pad) {
+						whitespace -= getComputedStyle(target, pad, TRUE);
+					});
+					
+					ration = (whitespace / matrix.total);
+
+					return {
+						whitespace : whitespace,
+						ration : ration
+					};
+				};
+
+				distributeRatio = function (matrix, whitespace) {
+					var flexers = matrix.groups,
+					    keys = matrix.keys,
+					    flex,
+					    specificity,
+					    ration = whitespace.ration,
+					    widthRation,
+					    trueDim,
+					    newDimension;
+
+					forEach(keys, function (i, key) {
+						widthRation = (ration * key);
+
+						forEach(flexers[key], function (i, x) {
+							if (x.match) {
+								flex = x.match.getAttribute("data-flex");
+								specificity = x.match.getAttribute("data-specificity");
+
+								if (!flex || (specificity <= x.flexSpecificity)) {
+									x.match.setAttribute("data-flex", key);
+									x.match.setAttribute("data-specificity", x.flexSpecificity);
+									
+									trueDim = getComputedStyle(x.match, self.props.dim, TRUE);
+									newDimension = Math.max(0, (trueDim + widthRation));
+									appendPixelValue(x.match, self.props.dim, newDimension);
+								}
+							}
+						});
+					});
+					
+					// Float drop fix
+					// Test offset values. If different, let's bring the widow back
+					if (params.orient === HORIZONTAL || params.orient === INLINE_AXIS) {
+						floatDropFix(target, params, self);
+					}
+				};
+
+				matrix = createMatchMatrix(params.children, children, NULL);
+
+				if (matrix.total) {
+					params.hasFlex = TRUE;
+					
+					restrict = testForRestrictiveProperties(matrix);
+					whitespace = findTotalWhitespace(matrix);
+				
+					// Distribute the calculated ratios among the children
+					distro = distributeRatio(matrix, whitespace);
+				}
+			},
+			
+			boxAlign : function (target, children, params) {
+				var self = this,
+				    targetDimension,
+				    kidDimension,
+				    flexCheck = parentFlex(target);
+				
+				if (!SUPPORT && !flexCheck.flex && (params.orient === VERTICAL || params.orient === BLOCK_AXIS)) {
+					if (!dimensionValues(target, self.anti.dim)) {
+						appendPixelValue(target, self.anti.dim, NULL);
+					}
+					appendPixelValue(children, self.anti.dim, NULL);
+				}
+				
+				// Remove padding / border from target dimension
+				targetDimension = target[self.anti.out];
+				forEach(self.anti.pad, function (i, pad) {
+					targetDimension -= getComputedStyle(target, pad, TRUE);
+				});
+
+				switch (params.align) {
+				case "start" :
+					break;
+				
+				case "end" :
+					forEach(children, function (i, kid) {
+						kidDimension = targetDimension - kid[self.anti.out];
+						kidDimension -= getComputedStyle(kid, self.anti.opp, TRUE);
+						appendPixelValue(kid, self.anti.pos, kidDimension);
+					});
+					break;
+
+				case "center" :
+					forEach(children, function (i, kid) {
+						kidDimension = (targetDimension - kid[self.anti.out]) / 2;
+						appendPixelValue(kid, self.anti.pos, kidDimension);
+					});
+					break;
+				
+				default :
+					forEach(children, function (i, kid) {
+						switch (kid.nodeName.toLowerCase()) {
+						case "button" :
+						case "input" :
+						case "select" :
+							break;
+
+						default :
+							var subtract = 0;
+
+							forEach(self.anti.pad, function (i, pad) {
+								subtract += getComputedStyle(kid, pad, TRUE);
+								subtract += getComputedStyle(target, pad, TRUE);
+							});
+
+							kid.style[self.anti.dim] = "100%";
+							kidDimension = kid[self.anti.out] - subtract;
+							appendPixelValue(kid, self.anti.dim, NULL);
+
+							kidDimension = targetDimension;
+							kidDimension -= getComputedStyle(kid, self.anti.pos, TRUE);
+
+							forEach(self.anti.pad, function (i, pad) {
+								kidDimension -= getComputedStyle(kid, pad, TRUE);
+							});
+
+							kidDimension -= getComputedStyle(kid, self.anti.opp, TRUE);
+							kidDimension = Math.max(0, kidDimension);
+							
+							appendPixelValue(kid, self.anti.dim, kidDimension);
+							break;
+						}
+					});
+					break;
+				}
+			},
+			
+			boxPack : function (target, children, params) {
+				var self = this,
+				    groupDimension = 0,
+				    firstComputedMargin = 0,
+				    targetPadding = 0,
+				    totalDimension,
+				    fractionedDimension,
+				    currentDimension,
+				    remainder,
+				    length = children.length - 1,
+				    kid;
+
+				forEach(children, function (i, kid) {
+					groupDimension += kid[self.props.out];
+					groupDimension += getComputedStyle(kid, self.props.pos, TRUE);
+					groupDimension += getComputedStyle(kid, self.props.opp, TRUE);
+				});
+
+				firstComputedMargin = getComputedStyle(children[0], self.props.pos, TRUE);
+				totalDimension = target[self.props.out] - groupDimension;
+				
+				// Remove padding / border from target dimension
+				forEach(self.props.pad, function (i, pad) {
+					totalDimension -= getComputedStyle(target, pad, TRUE);
+				});
+				
+				// If totalDimension is less than 0, we have a problem...
+				if (totalDimension < 0) {
+					totalDimension = Math.max(0, totalDimension);
+				}
+
+				switch (params.pack) {
+				case "end" :
+					appendPixelValue(children[0], self.props.pos, targetPadding + firstComputedMargin + totalDimension);
+					break;
+
+				case "center" :
+					if (targetPadding) {
+						targetPadding /= 2;
+					}
+					
+					appendPixelValue(children[0], self.props.pos, targetPadding + firstComputedMargin + (totalDimension / 2));
+					break;
+
+				case "justify" :
+					fractionedDimension = Math.floor((targetPadding + totalDimension) / length);
+					remainder = (fractionedDimension * length) - totalDimension;
+					
+					var i = children.length - 1,
+					    value;
+					
+					while (i) {
+						kid = children[i];
+						currentDimension = fractionedDimension;
+
+						if (remainder) {
+							currentDimension++;
+							remainder++;
+						}
+						
+						value = getComputedStyle(kid, self.props.pos, TRUE) + currentDimension;
+						appendPixelValue(kid, self.props.pos, value);
+						
+						i--;
+					}
+					
+					break;
+				}
+				
+				// Float drop fix
+				// Test offset values. If different, let's bring the widow back
+				if ((params.pack === "end" || params.pack === "justify") && (params.orient === HORIZONTAL || params.orient === INLINE_AXIS)) {
+					floatDropFix(target, params, self);
+				}
+				
+				target.style.overflow = "";
+			}
+		},
+
+		setup : function (target, children, params) {
+			var self = this, matrix, flexCheck;
+			
+			if (!target || !children || !params) {
+				return;
+			}
+			
+			if (SUPPORT && SUPPORT.partialSupport) {
+				matrix = createMatchMatrix(params.children, children, NULL);
+				flexCheck = parentFlex(target);
+				children = sanitizeChildren(target, target.childNodes);
+				
+				self.properties.boxOrient.call(self, target, children, params);
+				
+				if (!matrix.total || !LIBRARY(params.nested).length) {
+					if ((params.align === "stretch") && !SUPPORT.boxAlignStretch && (!flexCheck.nested || !flexCheck.flex)) {
+						self.properties.boxAlign.call(self, target, children, params);
+					}
+
+					if ((params.pack === "justify") && !SUPPORT.boxPackJustify && !matrix.total) {
+						self.properties.boxPack.call(self, target, children, params);
+					}
+				}
+			} else if (!SUPPORT) {
+				forEach(self.properties, function (key, func) {
+					func.call(self, target, sanitizeChildren(target, target.childNodes), params);
+				});
+			}
+		},
+
+		trackDOM : function (params) {
+			attachResizeListener(this, params);
+		},
+
+		updateModel : function (params) {
+			var self = this,
+			    target = params.target,
+			    children = params.nodes;
+			
+			// Null properties
+			cleanPositioningProperties(children);
+			
+			if (params.flexMatrix || params.ordinalMatrix) {
+				params = updateChildValues(params);
+			}
+
+			self.setup(target, children, params);
+			self.bubbleUp(target, params);
+		},
+
+		renderModel : function (params) {
+			var self = this,
+			    target = params.target,
+			    nodes = target.childNodes;
+			
+			// Sanity check.
+			if (!target.length && !nodes) {
+				return false;
+			}
+			
+			params = ensureStructuralIntegrity(params, this);
+			
+			// Setup properties
+			self.updateModel(params);
+			
+			// Resize / DOM Polling Events
+			// Delay for an instant because IE6 is insane.
+			win.setTimeout(function () {
+				self.trackDOM(params);
+			}, 0);
+			
+			return self;
+		},
+		
+		bubbleUp : function (target, params) {
+			var self = this, flex,
+			    parent = params.target.parentNode;
+			
+			while (parent) {
+				flex = FLEX_BOXES[parent.FLX_DOM_ID];
+				
+				if (flex) {
+					cleanPositioningProperties(flex.nodes);
+					self.setup(flex.target, flex.nodes, flex);
+				}
+				
+				parent = parent.parentNode;
+			}
+		}
+	};
+	
+	FLX.updateInstance = function (target, params) {
+		var box;
+		
+		if (target) {
+			box = FLEX_BOXES[target.FLX_DOM_ID];
+			
+			if (box) {
+				box._instance.updateModel(box);
+			} else {
+				box = new FLX.box(params);
+			}
+		} else {
+			forEach(FLEX_BOXES, function (i, box) {
+				box._instance.updateModel(box);
+			});
+		}
+	};
+	
+	FLX.getInstance = function (target) {
+		return FLEX_BOXES[target.FLX_DOM_ID];
+	};
+	
+	FLX.destroyInstance = function (target) {
+		var box,
+		    destroy;
+		
+		destroy = function (box) {
+			box.target.FLX_DOM_ID = NULL;
+			box.target.style.cssText = EMPTY_STRING;
+			
+			forEach(box.children, function (i, x) {
+				x.match.style.cssText = EMPTY_STRING;
+			});
+		};
+		
+		if (target) {
+			box = FLEX_BOXES[target.FLX_DOM_ID];
+			
+			if (box) {
+				destroy(box);
+			}
+		} else {
+			forEach(FLEX_BOXES, function (i, box) {
+				destroy(box);
+			});
+			
+			FLEX_BOXES = [];
+		}
+	};
+
+	FLX.flexboxSupport = function () {
+		var partialSupportGrid = {},
+		    height = 100,
+		    childHeight,
+		    dummy = doc.createElement("flxbox"),
+		    child = '<b style="margin: 0; padding: 0; display:block; width: 10px; height:' + (height / 2) + 'px"></b>',
+		    tests,
+		    result;
+
+		dummy.style.width = dummy.style.height = height + "px";
+		dummy.innerHTML = (child + child + child);
+
+		appendProperty(dummy, "display", "box", NULL);
+		appendProperty(dummy, "box-align", "stretch", TRUE);
+		appendProperty(dummy, "box-pack", "justify", TRUE);
+
+		doc.body.appendChild(dummy);
+		childHeight = dummy.firstChild.offsetHeight;
+		
+		tests = {
+			boxAlignStretch : function () {
+				return (childHeight === 100);
+			},
+			
+			boxPackJustify : function () {
+				var totalOffset = 0;
+				
+				forEach(dummy.childNodes, function (i, child) {
+					totalOffset += child.offsetLeft;
+				});
+				
+				return (totalOffset === 135);
+			}
+		};
+		
+		forEach(tests, function (key, value) {
+			result = value();
+			
+			if (!result) {
+				partialSupportGrid.partialSupport = TRUE;
+			}
+			
+			partialSupportGrid[key] = result;
+		});
+		
+		doc.body.removeChild(dummy);
+		return ~ (dummy.style.display).indexOf("box") ? partialSupportGrid : FALSE;
+	};
+	
+	FLX.init = function () {
+		FLX.flexboxSupported = SUPPORT = FLX.flexboxSupport();
+
+		if ((!SUPPORT || SUPPORT.partialSupport) && LIBRARY) {
+			selectivizrEngine();
+		}
+	};
+	
+	// Flexie Version
+	FLX.version = 1.0;
+
+	// Load when the DOM is ready
+	attachLoadMethod(FLX.init);
+	
+	return FLX;
+}(this, document));