path: root/point/libs/text/text.js

/**
 * @license RequireJS text 2.0.12 Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved.
 * Available via the MIT or new BSD license.
 * see: http://github.com/requirejs/text for details
 */
/*jslint regexp: true */
/*global require, XMLHttpRequest, ActiveXObject,
 define, window, process, Packages,
 java, location, Components, FileUtils */

define(['module'], function (module) {
	'use strict';

	var text, fs, Cc, Ci, xpcIsWindows,
		progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'],
		xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,
		bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im,
		hasLocation = typeof location !== 'undefined' && location.href,
		defaultProtocol = hasLocation && location.protocol && location.protocol.replace(/\:/, ''),
		defaultHostName = hasLocation && location.hostname,
		defaultPort = hasLocation && (location.port || undefined),
		buildMap = {},
		masterConfig = (module.config && module.config()) || {};

	text = {
		version: '2.0.12',

		strip: function (content) {
			//Strips <?xml ...?> declarations so that external SVG and XML
			//documents can be added to a document without worry. Also, if the string
			//is an HTML document, only the part inside the body tag is returned.
			if (content) {
				content = content.replace(xmlRegExp, "");
				var matches = content.match(bodyRegExp);
				if (matches) {
					content = matches[1];
				}
			} else {
				content = "";
			}
			return content;
		},

		jsEscape: function (content) {
			return content.replace(/(['\\])/g, '\\$1')
				.replace(/[\f]/g, "\\f")
				.replace(/[\b]/g, "\\b")
				.replace(/[\n]/g, "\\n")
				.replace(/[\t]/g, "\\t")
				.replace(/[\r]/g, "\\r")
				.replace(/[\u2028]/g, "\\u2028")
				.replace(/[\u2029]/g, "\\u2029");
		},

		createXhr: masterConfig.createXhr || function () {
			//Would love to dump the ActiveX crap in here. Need IE 6 to die first.
			var xhr, i, progId;
			if (typeof XMLHttpRequest !== "undefined") {
				return new XMLHttpRequest();
			} else if (typeof ActiveXObject !== "undefined") {
				for (i = 0; i < 3; i += 1) {
					progId = progIds[i];
					try {
						xhr = new ActiveXObject(progId);
					} catch (e) {
					}

					if (xhr) {
						progIds = [progId];  // so faster next time
						break;
					}
				}
			}

			return xhr;
		},

		/**
		 * Parses a resource name into its component parts. Resource names
		 * look like: module/name.ext!strip, where the !strip part is
		 * optional.
		 * @param {String} name the resource name
		 * @returns {Object} with properties "moduleName", "ext" and "strip"
		 * where strip is a boolean.
		 */
		parseName: function (name) {
			var modName, ext, temp,
				strip = false,
				index = name.indexOf("."),
				isRelative = name.indexOf('./') === 0 ||
					name.indexOf('../') === 0;

			if (index !== -1 && (!isRelative || index > 1)) {
				modName = name.substring(0, index);
				ext = name.substring(index + 1, name.length);
			} else {
				modName = name;
			}

			temp = ext || modName;
			index = temp.indexOf("!");
			if (index !== -1) {
				//Pull off the strip arg.
				strip = temp.substring(index + 1) === "strip";
				temp = temp.substring(0, index);
				if (ext) {
					ext = temp;
				} else {
					modName = temp;
				}
			}

			return {
				moduleName: modName,
				ext: ext,
				strip: strip
			};
		},

		xdRegExp: /^((\w+)\:)?\/\/([^\/\\]+)/,

		/**
		 * Is an URL on another domain. Only works for browser use, returns
		 * false in non-browser environments. Only used to know if an
		 * optimized .js version of a text resource should be loaded
		 * instead.
		 * @param {String} url
		 * @returns Boolean
		 */
		useXhr: function (url, protocol, hostname, port) {
			var uProtocol, uHostName, uPort,
				match = text.xdRegExp.exec(url);
			if (!match) {
				return true;
			}
			uProtocol = match[2];
			uHostName = match[3];

			uHostName = uHostName.split(':');
			uPort = uHostName[1];
			uHostName = uHostName[0];

			return (!uProtocol || uProtocol === protocol) &&
				(!uHostName || uHostName.toLowerCase() === hostname.toLowerCase()) &&
				((!uPort && !uHostName) || uPort === port);
		},

		finishLoad: function (name, strip, content, onLoad) {
			content = strip ? text.strip(content) : content;
			if (masterConfig.isBuild) {
				buildMap[name] = content;
			}
			onLoad(content);
		},

		load: function (name, req, onLoad, config) {
			//Name has format: some.module.filext!strip
			//The strip part is optional.
			//if strip is present, then that means only get the string contents
			//inside a body tag in an HTML string. For XML/SVG content it means
			//removing the <?xml ...?> declarations so the content can be inserted
			//into the current doc without problems.

			// Do not bother with the work if a build and text will
			// not be inlined.
			if (config && config.isBuild && !config.inlineText) {
				onLoad();
				return;
			}

			masterConfig.isBuild = config && config.isBuild;

			var parsed = text.parseName(name),
				nonStripName = parsed.moduleName +
					(parsed.ext ? '.' + parsed.ext : ''),
				url = req.toUrl(nonStripName),
				useXhr = (masterConfig.useXhr) ||
					text.useXhr;

			// Do not load if it is an empty: url
			if (url.indexOf('empty:') === 0) {
				onLoad();
				return;
			}

			//Load the text. Use XHR if possible and in a browser.
			if (!hasLocation || useXhr(url, defaultProtocol, defaultHostName, defaultPort)) {
				text.get(url, function (content) {
					text.finishLoad(name, parsed.strip, content, onLoad);
				}, function (err) {
					if (onLoad.error) {
						onLoad.error(err);
					}
				});
			} else {
				//Need to fetch the resource across domains. Assume
				//the resource has been optimized into a JS module. Fetch
				//by the module name + extension, but do not include the
				//!strip part to avoid file system issues.
				req([nonStripName], function (content) {
					text.finishLoad(parsed.moduleName + '.' + parsed.ext,
						parsed.strip, content, onLoad);
				});
			}
		},

		write: function (pluginName, moduleName, write, config) {
			if (buildMap.hasOwnProperty(moduleName)) {
				var content = text.jsEscape(buildMap[moduleName]);
				write.asModule(pluginName + "!" + moduleName,
						"define(function () { return '" +
						content +
						"';});\n");
			}
		},

		writeFile: function (pluginName, moduleName, req, write, config) {
			var parsed = text.parseName(moduleName),
				extPart = parsed.ext ? '.' + parsed.ext : '',
				nonStripName = parsed.moduleName + extPart,
			//Use a '.js' file name so that it indicates it is a
			//script that can be loaded across domains.
				fileName = req.toUrl(parsed.moduleName + extPart) + '.js';

			//Leverage own load() method to load plugin value, but only
			//write out values that do not have the strip argument,
			//to avoid any potential issues with ! in file names.
			text.load(nonStripName, req, function (value) {
				//Use own write() method to construct full module value.
				//But need to create shell that translates writeFile's
				//write() to the right interface.
				var textWrite = function (contents) {
					return write(fileName, contents);
				};
				textWrite.asModule = function (moduleName, contents) {
					return write.asModule(moduleName, fileName, contents);
				};

				text.write(pluginName, nonStripName, textWrite, config);
			}, config);
		}
	};

	if (masterConfig.env === 'node' || (!masterConfig.env &&
		typeof process !== "undefined" &&
		process.versions && !!process.versions.node && !process.versions['node-webkit'])) {
		//Using special require.nodeRequire, something added by r.js.
		fs = require.nodeRequire('fs');

		text.get = function (url, callback, errback) {
			try {
				var file = fs.readFileSync(url, 'utf8');
				//Remove BOM (Byte Mark Order) from utf8 files if it is there.
				if (file.indexOf('\uFEFF') === 0) {
					file = file.substring(1);
				}
				callback(file);
			} catch (e) {
				if (errback) {
					errback(e);
				}
			}
		};
	} else if (masterConfig.env === 'xhr' || (!masterConfig.env &&
		text.createXhr())) {
		text.get = function (url, callback, errback, headers) {
			var xhr = text.createXhr(), header;
			xhr.open('GET', url, true);

			//Allow plugins direct access to xhr headers
			if (headers) {
				for (header in headers) {
					if (headers.hasOwnProperty(header)) {
						xhr.setRequestHeader(header.toLowerCase(), headers[header]);
					}
				}
			}

			//Allow overrides specified in config
			if (masterConfig.onXhr) {
				masterConfig.onXhr(xhr, url);
			}

			xhr.onreadystatechange = function (evt) {
				var status, err;
				//Do not explicitly handle errors, those should be
				//visible via console output in the browser.
				if (xhr.readyState === 4) {
					status = xhr.status || 0;
					if (status > 399 && status < 600) {
						//An http 4xx or 5xx error. Signal an error.
						err = new Error(url + ' HTTP status: ' + status);
						err.xhr = xhr;
						if (errback) {
							errback(err);
						}
					} else {
						callback(xhr.responseText);
					}

					if (masterConfig.onXhrComplete) {
						masterConfig.onXhrComplete(xhr, url);
					}
				}
			};
			xhr.send(null);
		};
	} else if (masterConfig.env === 'rhino' || (!masterConfig.env &&
		typeof Packages !== 'undefined' && typeof java !== 'undefined')) {
		//Why Java, why is this so awkward?
		text.get = function (url, callback) {
			var stringBuffer, line,
				encoding = "utf-8",
				file = new java.io.File(url),
				lineSeparator = java.lang.System.getProperty("line.separator"),
				input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(file), encoding)),
				content = '';
			try {
				stringBuffer = new java.lang.StringBuffer();
				line = input.readLine();

				// Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
				// http://www.unicode.org/faq/utf_bom.html

				// Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:
				// http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058
				if (line && line.length() && line.charAt(0) === 0xfeff) {
					// Eat the BOM, since we've already found the encoding on this file,
					// and we plan to concatenating this buffer with others; the BOM should
					// only appear at the top of a file.
					line = line.substring(1);
				}

				if (line !== null) {
					stringBuffer.append(line);
				}

				while ((line = input.readLine()) !== null) {
					stringBuffer.append(lineSeparator);
					stringBuffer.append(line);
				}
				//Make sure we return a JavaScript string and not a Java string.
				content = String(stringBuffer.toString()); //String
			} finally {
				input.close();
			}
			callback(content);
		};
	} else if (masterConfig.env === 'xpconnect' || (!masterConfig.env &&
		typeof Components !== 'undefined' && Components.classes &&
		Components.interfaces)) {
		//Avert your gaze!
		Cc = Components.classes;
		Ci = Components.interfaces;
		Components.utils['import']('resource://gre/modules/FileUtils.jsm');
		xpcIsWindows = ('@mozilla.org/windows-registry-key;1' in Cc);

		text.get = function (url, callback) {
			var inStream, convertStream, fileObj,
				readData = {};

			if (xpcIsWindows) {
				url = url.replace(/\//g, '\\');
			}

			fileObj = new FileUtils.File(url);

			//XPCOM, you so crazy
			try {
				inStream = Cc['@mozilla.org/network/file-input-stream;1']
					.createInstance(Ci.nsIFileInputStream);
				inStream.init(fileObj, 1, 0, false);

				convertStream = Cc['@mozilla.org/intl/converter-input-stream;1']
					.createInstance(Ci.nsIConverterInputStream);
				convertStream.init(inStream, "utf-8", inStream.available(),
					Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);

				convertStream.readString(inStream.available(), readData);
				convertStream.close();
				inStream.close();
				callback(readData.value);
			} catch (e) {
				throw new Error((fileObj && fileObj.path || '') + ': ' + e);
			}
		};
	}
	return text;
});