|
|
@@ -0,0 +1,390 @@
|
|
|
+/**
|
|
|
+ * @license text 2.0.14 Copyright jQuery Foundation and other contributors.
|
|
|
+ * Released under MIT license, http://github.com/requirejs/text/LICENSE
|
|
|
+ */
|
|
|
+/*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.14',
|
|
|
+
|
|
|
+ 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.lastIndexOf("."),
|
|
|
+ isRelative = name.indexOf('./') === 0 ||
|
|
|
+ name.indexOf('../') === 0;
|
|
|
+
|
|
|
+ if (index !== -1 && (!isRelative || index > 1)) {
|
|
|
+ modName = name.substring(0, index);
|
|
|
+ ext = name.substring(index + 1);
|
|
|
+ } 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'] &&
|
|
|
+ !process.versions['atom-shell'])) {
|
|
|
+ //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[0] === '\uFEFF') {
|
|
|
+ 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;
|
|
|
+});
|