RubyGems - bixbite - Versions diffs - 0.1.0 - Mend

bixbite 0.1.0

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 (194) hide show

data/template/src/html/index.html ADDED

@@ -0,0 +1,35 @@
+<?php
+require('includes/namespace.inc');
+$page->setPageTitle('Index');
+ob_start();
+?>
+			<!-- Start [#content] -->
+			<div id="content">
+				<h1>Completed Pages</h1>
+				<div id="contentWrapper">
+					<ul style="font-size: 16px; line-height: 1.5;">
+<?php
+foreach ($page->listFilesInDirectory(SITE_ROOT, "html") as $key => $value) {
+	if ($value != "index.html") {
+		$raw = file_get_contents(SITE_ROOT . $value);
+		$regex = '/\$page->setPageTitle\(\'([^\']+)\'\)/';
+		preg_match($regex, $raw, $matches, PREG_OFFSET_CAPTURE);
+		$title = $matches[1][0];
+		echo "\t\t\t\t\t" . '<li><a href="' . $value . '">' . $title . '</a></li>' . "\n";
+	}
+}
+?>
+					</ul>
+				</div>
+			</div>
+			<!-- End [#content] -->
+<?php $page->output(ob_get_clean()); ?>

data/template/src/html/js/cmn/bootstrap.js ADDED

@@ -0,0 +1,74 @@
+/*
+File: bootstrap.js
+About: Version
+	1.0
+Project: __PROJECT_NAME__
+Description:
+	This should be included directly after the opening <body> tag.
+	If a module required a <script> tag in the middle of the page
+	markup, queue up the code in a function so that jQuery and other
+	dependencies are available for the code runs.
+Example:
+	><script type="text/javascript">
+	>	__PROJECT_NAMESPACE__.queue(function() {
+	>		// do something with jQuery, etc
+	>	});
+	></script>
+	>
+	>...
+	>
+	>$(document).ready(function() {
+	>	__PROJECT_NAMESPACE__.unqueue();
+	>})
+*/
+/*
+Class: __PROJECT_NAMESPACE__
+	Scoped to the __PROJECT_NAMESPACE__ Global Namespace
+*/
+var __PROJECT_NAMESPACE__ = window.__PROJECT_NAMESPACE__ || {};
+(function(__PROJECT_NAMESPACE__) {
+	document.body.className += " js-enabled";
+	var queue = [];
+	/*
+	method: queue
+	 	Adds functions to a queuer to be deployed once the DOM is ready
+	Parameters:
+		arguments - the function (or functions) to add to the queue
+	*/
+	__PROJECT_NAMESPACE__.queue = function() {
+		for (var i = -1, func; func = arguments[++i];) {
+			queue[queue.length] = func;
+		}
+	};
+	/*
+	method: unqueue
+	 	Fires each queued function
+	*/
+	__PROJECT_NAMESPACE__.unqueue = function() {
+		var func;
+		while (queue != null && (func = queue.shift())) {
+			func();
+		}
+		// Nullify
+		for (var i = (queue != null) ? queue.length - 1 : -1; i >= 0; i--) {
+			queue[i] = null;
+		}
+		queue = null;
+	};
+}(__PROJECT_NAMESPACE__));

data/template/src/html/js/cmn/global.js ADDED

@@ -0,0 +1,142 @@
+/*
+File: global.js
+About: Version
+	1.0
+Project: __PROJECT_NAME__
+Description:
+	A common file that includes all globally shared functionality for __PROJECT_NAMESPACE__
+Requires:
+	- LABjs <http://labjs.com/>
+	- __JS_LIB__
+Requires:
+	- <bootstrap.js>
+*/
+/*
+Class: __PROJECT_NAMESPACE__
+	Scoped to the __PROJECT_NAMESPACE__ Global Namespace
+*/
+var __PROJECT_NAMESPACE__ = window.__PROJECT_NAMESPACE__ || {};
+// When the DOM is ready.
+(function () {
+	// Storing a variable to reference
+	var $self = __PROJECT_NAMESPACE__;
+	/*
+	Namespace: __PROJECT_NAMESPACE__.vars
+		Shared global variables
+	*/
+	$self.vars = {
+		/*
+		variable: queue
+			Contains the functions ready to be fired on DOM ready
+		*/
+		queue : []
+	};
+	/*
+	Namespace: __PROJECT_NAMESPACE__.legacy
+		A legacy namespace to be used if __PROJECT_NAMESPACE__ has any legacy dependencies
+	*/
+	$self.legacy = {};
+	/*
+	Namespace: __PROJECT_NAMESPACE__.utils
+		Shared global utilities
+	*/
+	$self.utils = {
+		/*
+		sub: ie6Check
+		 	Adds an IE6 flag to jQuery
+		*/
+		ie6Check : function() {
+			// Let's set a flag for IE 6
+			$.extend($.browser, {
+				ie6 : function () {
+					return !!($.browser.msie && $.browser.version == 6);
+				}()
+			});
+		}(),
+		/*
+		sub: queue
+		 	A global initializer. Takes a function argument and queues it until <init> is fired
+		Parameters:
+			object - The function to initialize when the DOM is ready
+		Example:
+			>__PROJECT_NAMESPACE__.utils.queue(function() {
+			>	// Add code here
+			>});
+		*/
+		queue : function (object) {
+			$self.vars.queue.push(object);
+		},
+		/*
+		sub: init
+		 	When fired, loops through $self.vars.queue and fires each queued function
+		*/
+		init : function() {
+			var queue = $self.vars.queue;
+			$.each(queue, function(i, object) {
+				for (var key in object) {
+					if (object.hasOwnProperty(key) && (typeof object[key] === "function")) {
+						object[key]();
+					}
+				}
+			});
+		}
+	};
+	/*
+	Namespace: __PROJECT_NAMESPACE__
+		Under the __PROJECT_NAMESPACE__ Local Namespace
+	*/
+	/*
+	Function: global
+	 	Takes care of a few global functionalities:
+		- Fires __PROJECT_NAMESPACE__.unqueue
+		- Overrides the default jQuery easing
+		- Adds the IE BackgroundImageCache fix
+	*/
+	$self.global = function () {
+		// Unqueue inline functions
+		__PROJECT_NAMESPACE__.unqueue();
+		if ($.browser.msie) {
+			try {
+				// Enable background image cache
+			    document.execCommand("BackgroundImageCache", false, true);
+			} catch (ex) {}
+		}
+	};
+	/*
+	Function: header
+	 	Encapsulates functionality found in the #header space
+	*/
+	$self.header = function() {};
+	/*
+	Callback: init
+		Sends local functions to a global queuer for initialization See: <__PROJECT_NAMESPACE__.utils.queue>
+	*/
+	$self.utils.queue($self);
+}).call(__PROJECT_NAMESPACE__);

data/template/src/html/js/cmn/lib/LAB.js ADDED

@@ -0,0 +1,348 @@
+// LAB.js (LABjs :: Loading And Blocking JavaScript)
+// v1.0.1 (c) Kyle Simpson
+// MIT License
+(function(global){
+	var sSTRING = "string",				// constants used for compression optimization
+		sHEAD = "head",
+		sBODY = "body",
+		sSCRIPT = "script",
+		sREADYSTATE = "readyState",
+		sPRELOADDONE = "preloaddone",
+		sLOADTRIGGER = "loadtrigger",
+		sSRCURI = "srcuri",
+		sPRELOAD = "preload",
+		sCOMPLETE = "complete",
+		sDONE = "done",
+		sWHICH = "which",
+		sONREADYSTATECHANGE = "onreadystatechange",
+		sONLOAD = "onload",
+		sHASOWNPROPERTY = "hasOwnProperty",
+		nNULL = null,
+		bTRUE = true,
+		bFALSE = false,
+		oDOC = global.document,
+		oDOCLOC = oDOC.location,
+		oACTIVEX = global.ActiveXObject,
+		fSETTIMEOUT = global.setTimeout,
+		fCLEARTIMEOUT = global.clearTimeout,
+		fGETELEMENTSBYTAGNAME = function(tn){return oDOC.getElementsByTagName(tn);},
+		fOBJTOSTRING = Object.prototype.toString,
+		fNOOP = function(){},
+		append_to = {},
+		all_scripts = {},
+		PAGEROOT = /^[^?#]*\//.exec(oDOCLOC.href)[0], // these ROOTs do not support file:/// usage, only http:// type usage
+		DOCROOT = /^\w+\:\/\/\/?[^\/]+/.exec(PAGEROOT)[0], // optional third / in the protocol portion of this regex so that LABjs doesn't blow up when used in file:/// usage
+		docScripts = fGETELEMENTSBYTAGNAME(sSCRIPT),
+		// Ah-ha hush that fuss, feature inference is used to detect specific browsers
+		// because the techniques used in LABjs have no known feature detection. If
+		// you know of a feature test please contact me ASAP. Feature inference is used
+		// instead of user agent sniffing because the UA string can be easily
+		// spoofed and is not adequate for such a mission critical part of the code.
+		is_opera = global.opera && fOBJTOSTRING.call(global.opera) == "[object Opera]",
+		is_gecko = (function(o) { o[o] = o+""; return o[o] != o+""; })(new String("__count__")),
+		global_defs = {
+			cache:!(is_gecko||is_opera), // browsers like IE/Safari/Chrome can use the "cache" trick to preload
+			order:is_gecko||is_opera, // FF/Opera preserve execution order with script tags automatically, so just add all scripts as fast as possible
+			xhr:bTRUE, // use XHR trick to preload local scripts
+			dupe:bTRUE, // allow duplicate scripts? defaults to true now 'cause is slightly more performant that way (less checks)
+			preserve:bFALSE, // preserve execution order of all loaded scripts (regardless of preloading)
+			base:"", // base path to prepend to all non-absolute-path scripts
+			which:sHEAD // which DOM object ("head" or "body") to append scripts to
+		}
+	;
+	global_defs[sPRELOAD] = bTRUE; // use various tricks for "preloading" scripts
+	append_to[sHEAD] = fGETELEMENTSBYTAGNAME(sHEAD);
+	append_to[sBODY] = fGETELEMENTSBYTAGNAME(sBODY);
+	function isFunc(func) { return fOBJTOSTRING.call(func) === "[object Function]"; }
+	function canonicalScriptURI(src,base_path) {
+		var regex = /^\w+\:\/\//, ret;
+		if (typeof src !== sSTRING) src = "";
+		if (typeof base_path !== sSTRING) base_path = "";
+		ret = (regex.test(src) ? "" : base_path) + src;
+		return ((regex.test(ret) ? "" : (ret.charAt(0) === "/" ? DOCROOT : PAGEROOT)) + ret);
+	}
+	function sameDomain(src) { return (canonicalScriptURI(src).indexOf(DOCROOT) === 0); }
+	function scriptTagExists(uri) { // checks if a script uri has ever been loaded into this page's DOM
+		var i = 0, script;
+		while (script = docScripts[i++]) {
+			if (typeof script.src === sSTRING && uri === canonicalScriptURI(script.src) && script.getAttribute("rel") !== sPRELOAD) return bTRUE;
+		}
+		return bFALSE;
+	}
+	function engine(queueExec,opts) {
+		queueExec = !(!queueExec);
+		if (opts == nNULL) opts = global_defs;
+		var ready = bFALSE,
+			_use_preload = queueExec && opts[sPRELOAD],
+			_use_cache_preload = _use_preload && opts.cache,
+			_use_script_order = _use_preload && opts.order,
+			_use_xhr_preload = _use_preload && opts.xhr,
+			_auto_wait = opts.preserve,
+			_which = opts.which,
+			_base_path = opts.base,
+			waitFunc = fNOOP,
+			scripts_loading = bFALSE,
+			publicAPI,
+			first_pass = bTRUE,
+			scripts = {},
+			exec = [],
+			end_of_chain_check_interval = null
+		;
+		_use_preload = _use_cache_preload || _use_xhr_preload || _use_script_order; // if all flags are turned off, preload is moot so disable it
+		function isScriptLoaded(elem,scriptentry) {
+			if ((elem[sREADYSTATE] && elem[sREADYSTATE]!==sCOMPLETE && elem[sREADYSTATE]!=="loaded") || scriptentry[sDONE]) { return bFALSE; }
+			elem[sONLOAD] = elem[sONREADYSTATECHANGE] = nNULL; // prevent memory leak
+			return bTRUE;
+		}
+		function handleScriptLoad(elem,scriptentry,skipReadyCheck) {
+			skipReadyCheck = !(!skipReadyCheck); // used to override ready check when script text was injected from XHR preload
+			if (!skipReadyCheck && !(isScriptLoaded(elem,scriptentry))) return;
+			scriptentry[sDONE] = bTRUE;
+			for (var key in scripts) {
+				if (scripts[sHASOWNPROPERTY](key) && !(scripts[key][sDONE])) return;
+			}
+			ready = bTRUE;
+			waitFunc();
+		}
+		function loadTriggerExecute(scriptentry) {
+			if (isFunc(scriptentry[sLOADTRIGGER])) {
+				scriptentry[sLOADTRIGGER]();
+				scriptentry[sLOADTRIGGER] = nNULL; // prevent memory leak
+			}
+		}
+		function handleScriptPreload(elem,scriptentry) {
+			if (!isScriptLoaded(elem,scriptentry)) return;
+			scriptentry[sPRELOADDONE] = bTRUE;
+			fSETTIMEOUT(function(){
+				append_to[scriptentry[sWHICH]][0].removeChild(elem); // remove preload script node
+				loadTriggerExecute(scriptentry);
+			},0);
+		}
+		function handleXHRPreload(xhr,scriptentry) {
+			if (xhr[sREADYSTATE] === 4) {
+				xhr[sONREADYSTATECHANGE] = fNOOP; // fix a memory leak in IE
+				scriptentry[sPRELOADDONE] = bTRUE;
+				fSETTIMEOUT(function(){ loadTriggerExecute(scriptentry); },0);
+			}
+		}
+		function createScriptTag(scriptentry,src,type,charset,rel,onload,scriptText) {
+			fSETTIMEOUT(function(){
+				if (append_to[scriptentry[sWHICH]][0] === nNULL) { // append_to object not yet ready
+					fSETTIMEOUT(arguments.callee,25);
+					return;
+				}
+				var scriptElem = oDOC.createElement(sSCRIPT), fSETATTRIBUTE = function(attr,val){scriptElem.setAttribute(attr,val);};
+				fSETATTRIBUTE("type",type);
+				fSETATTRIBUTE("rel",rel);
+				if (typeof charset === sSTRING) fSETATTRIBUTE("charset",charset);
+				if (isFunc(onload)) { // load script via 'src' attribute, set onload/onreadystatechange listeners
+					scriptElem[sONLOAD] = scriptElem[sONREADYSTATECHANGE] = function(){onload(scriptElem,scriptentry);};
+					fSETATTRIBUTE("src",src);
+				}
+				append_to[scriptentry[sWHICH]][0].appendChild(scriptElem);
+				if (typeof scriptText === sSTRING) { // script text already avaiable from XHR preload, so just inject it
+					scriptElem.text = scriptText;
+					handleScriptLoad(scriptElem,scriptentry,bTRUE); // manually call 'load' callback function, skipReadyCheck=true
+				}
+			},0);
+		}
+		function loadScriptElem(scriptentry,src,type,charset) {
+			all_scripts[scriptentry[sSRCURI]] = bTRUE;
+			createScriptTag(scriptentry,src,type,charset,"",handleScriptLoad);
+		}
+		function loadScriptCache(scriptentry,src,type,charset) {
+			var args = arguments;
+			if (first_pass && scriptentry[sPRELOADDONE] == nNULL) { // need to preload into cache
+				scriptentry[sPRELOADDONE] = bFALSE;
+				createScriptTag(scriptentry,src,"text/html",charset,sPRELOAD,handleScriptPreload); // "text/html" causes a fetch into cache, but no execution
+			}
+			else if (!first_pass && scriptentry[sPRELOADDONE] != nNULL && !scriptentry[sPRELOADDONE]) { // preload still in progress, make sure trigger is set for execution later
+				scriptentry[sLOADTRIGGER] = function(){loadScriptCache.apply(nNULL,args);};
+			}
+			else if (!first_pass) { // preload done, so reload (from cache, hopefully!) as regular script element
+				loadScriptElem.apply(nNULL,args);
+			}
+		}
+		function loadScriptXHR(scriptentry,src,type,charset) {
+			var args = arguments, xhr;
+			if (first_pass && scriptentry[sPRELOADDONE] == nNULL) { // need to preload
+				scriptentry[sPRELOADDONE] = bFALSE;
+				xhr = scriptentry.xhr = (oACTIVEX ? new oACTIVEX("Microsoft.XMLHTTP") : new global.XMLHttpRequest());
+				xhr[sONREADYSTATECHANGE] = function(){handleXHRPreload(xhr,scriptentry);};
+				xhr.open("GET",src);
+				xhr.send("");
+			}
+			else if (!first_pass && scriptentry[sPRELOADDONE] != nNULL && !scriptentry[sPRELOADDONE]) {	// preload XHR still in progress, make sure trigger is set for execution later
+				scriptentry[sLOADTRIGGER] = function(){loadScriptXHR.apply(nNULL,args);};
+			}
+			else if (!first_pass) { // preload done, so "execute" script via injection
+				all_scripts[scriptentry[sSRCURI]] = bTRUE;
+				createScriptTag(scriptentry,src,type,charset,"",nNULL,scriptentry.xhr.responseText);
+				scriptentry.xhr = nNULL;
+			}
+		}
+		function loadScript(o) {
+			if (o.allowDup == nNULL) o.allowDup = opts.dupe;
+			var src = o.src, type = o.type, charset = o.charset, allowDup = o.allowDup,
+				src_uri = canonicalScriptURI(src,_base_path), scriptentry, same_domain = sameDomain(src_uri);
+			if (typeof type !== sSTRING) type = "text/javascript";
+			if (typeof charset !== sSTRING) charset = nNULL;
+			allowDup = !(!allowDup);
+			if (!allowDup &&
+				(
+					(all_scripts[src_uri] != nNULL) || (first_pass && scripts[src_uri]) || scriptTagExists(src_uri)
+				)
+			) {
+				if (scripts[src_uri] != nNULL && scripts[src_uri][sPRELOADDONE] && !scripts[src_uri][sDONE] && same_domain) {
+					// this script was preloaded via XHR, but is a duplicate, and dupes are not allowed
+					handleScriptLoad(nNULL,scripts[src_uri],bTRUE); // mark the entry as done and check if chain group is done
+				}
+				return;
+			}
+			if (scripts[src_uri] == nNULL) scripts[src_uri] = {};
+			scriptentry = scripts[src_uri];
+			if (scriptentry[sWHICH] == nNULL) scriptentry[sWHICH] = _which;
+			scriptentry[sDONE] = bFALSE;
+			scriptentry[sSRCURI] = src_uri;
+			scripts_loading = bTRUE;
+			if (!_use_script_order && _use_xhr_preload && same_domain) loadScriptXHR(scriptentry,src_uri,type,charset);
+			else if (!_use_script_order && _use_cache_preload) loadScriptCache(scriptentry,src_uri,type,charset);
+			else loadScriptElem(scriptentry,src_uri,type,charset);
+		}
+		function onlyQueue(execBody) {
+			exec.push(execBody);
+		}
+		function queueAndExecute(execBody) { // helper for publicAPI functions below
+			if (queueExec && !_use_script_order) onlyQueue(execBody);
+			if (!queueExec || _use_preload) execBody(); // if engine is either not queueing, or is queuing in preload mode, go ahead and execute
+		}
+		function serializeArgs(args) {
+			var sargs = [], i;
+			for (i=0; i<args.length; i++) {
+				if (fOBJTOSTRING.call(args[i]) === "[object Array]") sargs = sargs.concat(serializeArgs(args[i]));
+				else sargs[sargs.length] = args[i];
+			}
+			return sargs;
+		}
+		publicAPI = {
+			script:function() {
+				fCLEARTIMEOUT(end_of_chain_check_interval);
+				var args = serializeArgs(arguments), use_engine = publicAPI;
+				if (_auto_wait) {
+					for (var i=0; i<args.length; i++) {
+						if (i===0) {
+							queueAndExecute(function(){
+								loadScript((typeof args[0] === sSTRING) ? {src:args[0]} : args[0]);
+							});
+						}
+						else use_engine = use_engine.script(args[i]);
+						use_engine = use_engine.wait();
+					}
+				}
+				else {
+					queueAndExecute(function(){
+						for (var i=0; i<args.length; i++) {
+							loadScript((typeof args[i] === sSTRING) ? {src:args[i]} : args[i]);
+						}
+					});
+				}
+				end_of_chain_check_interval = fSETTIMEOUT(function(){first_pass = bFALSE;},5); // hack to "detect" the end of the chain if a wait() is not the last call
+				return use_engine;
+			},
+			wait:function(func) {
+				fCLEARTIMEOUT(end_of_chain_check_interval);
+				first_pass = bFALSE;
+				if (!isFunc(func)) func = fNOOP;
+				// On this current chain's waitFunc function, tack on call to trigger the queue for the *next* engine
+				// in the chain, which will be executed when the current chain finishes loading
+				var e = engine(bTRUE,opts),	// 'bTRUE' tells the engine to be in queueing mode
+					triggerNextChain = e.trigger, // store ref to e's trigger function for use by 'wfunc'
+					wfunc = function(){ try { func(); } catch(err) {} triggerNextChain(); };
+				delete e.trigger; // remove the 'trigger' property from e's public API, since only used internally
+				var fn = function(){
+					if (scripts_loading && !ready) waitFunc = wfunc;
+					else fSETTIMEOUT(wfunc,0);
+				};
+				if (queueExec && !scripts_loading) onlyQueue(fn);
+				else queueAndExecute(fn);
+				return e;
+			}
+		};
+		publicAPI.block = publicAPI.wait;	// alias "block" to "wait" -- "block" is now deprecated
+		if (queueExec) {
+			// if queueing, return a function that the previous chain's waitFunc function can use to trigger this
+			// engine's queue. NOTE: this trigger function is captured and removed from the public chain API before return
+			publicAPI.trigger = function() {
+				var i=0, fn;
+				while (fn = exec[i++]) fn();
+				exec = [];
+			};
+		}
+		return publicAPI;
+	}
+	function processOpts(opts) {
+		var k, newOpts = {},
+			boolOpts = {"UseCachePreload":"cache","UseLocalXHR":"xhr","UsePreloading":sPRELOAD,"AlwaysPreserveOrder":"preserve","AllowDuplicates":"dupe"},
+			allOpts = {"AppendTo":"which","BasePath":"base"}
+		;
+		for (k in boolOpts) allOpts[k] = boolOpts[k];
+		newOpts.order = !(!global_defs.order);
+		for (k in allOpts) {
+			if (allOpts[sHASOWNPROPERTY](k) && global_defs[allOpts[k]] != nNULL) newOpts[allOpts[k]] = (opts[k] != nNULL) ? opts[k] : global_defs[allOpts[k]];
+		}
+		for (k in boolOpts) { // normalize bool props to actual boolean values if not already
+			if (boolOpts[sHASOWNPROPERTY](k)) newOpts[boolOpts[k]] = !(!newOpts[boolOpts[k]]);
+		}
+		if (!newOpts[sPRELOAD]) newOpts.cache = newOpts.order = newOpts.xhr = bFALSE; // turn off all flags if preloading is disabled
+		newOpts.which = (newOpts.which === sHEAD || newOpts.which === sBODY) ? newOpts.which : sHEAD;
+		return newOpts;
+	}
+	global.$LAB = {
+		setGlobalDefaults:function(gdefs) { // intentionally does not return an "engine" instance -- must call as stand-alone function call on $LAB
+			global_defs = processOpts(gdefs);
+		},
+		setOptions:function(opts){ // set options per chain
+			return engine(bFALSE,processOpts(opts));
+		},
+		script:function(){ // will load one or more scripts
+			return engine().script.apply(nNULL,arguments);
+		},
+		wait:function(){ // will ensure that the chain's previous scripts are executed before execution of scripts in subsequent chain links
+			return engine().wait.apply(nNULL,arguments);
+		}
+	};
+	global.$LAB.block = global.$LAB.wait;	// alias "block" to "wait" -- "block" is now deprecated
+	/* The following "hack" was suggested by Andrea Giammarchi and adapted from: http://webreflection.blogspot.com/2009/11/195-chars-to-help-lazy-loading.html
+	   NOTE: this hack only operates in FF and then only in versions where document.readyState is not present (FF < 3.6?).
+	   The hack essentially "patches" the **page** that LABjs is loaded onto so that it has a proper conforming document.readyState, so that if a script which does
+	   proper and safe dom-ready detection is loaded onto a page, after dom-ready has passed, it will still be able to detect this state, by inspecting the now hacked
+	   document.readyState property. The loaded script in question can then immediately trigger any queued code executions that were waiting for the DOM to be ready.
+	   For instance, jQuery > 1.3.2 has been patched to take advantage of document.readyState, which is enabled by this hack. But 1.3.2 and before are **not** safe or
+	   affected by this hack, and should therefore **not** be lazy-loaded by script loader tools such as LABjs.
+	*/
+	(function(addEvent,domLoaded,handler){
+		if (oDOC[sREADYSTATE] == nNULL && oDOC[addEvent]){
+			oDOC[sREADYSTATE] = "loading";
+			oDOC[addEvent](domLoaded,handler = function(){
+				oDOC.removeEventListener(domLoaded,handler,bFALSE);
+				oDOC[sREADYSTATE] = sCOMPLETE;
+			},bFALSE);
+		}
+	})("addEventListener","DOMContentLoaded");
+})(window);