RubyGems - bixbite - Versions diffs - 0.1.0 - Mend

bixbite 0.1.0

Files changed (194) hide show

@@ -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);