wikked: static/js/text.js comparison

comparison static/js/text.js @ 60:8250c977bc50

Moved static files to the root directory.

author	Ludovic Chabant <ludovic@chabant.com>
date	Tue, 05 Feb 2013 14:49:34 -0800
parents	wikked/static/js/text.js@9658edea3121
children

comparison

equal deleted inserted replaced

-:59ecc742ab8e
+:8250c977bc50
+/**
+* @license RequireJS text 2.0.4 Copyright (c) 2010-2012, 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: false, XMLHttpRequest: false, ActiveXObject: false,
+define: false, window: false, process: false, Packages: false,
+java: false, location: false */
+define(['module'], function (module) {
+'use strict';
+var text, fs,
+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.4',
+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.isBuild && !config.inlineText) {
+onLoad();
+return;
+}
+masterConfig.isBuild = config.isBuild;
+var parsed = text.parseName(name),
+nonStripName = parsed.moduleName +
+(parsed.ext ? '.' + parsed.ext : ''),
+url = req.toUrl(nonStripName),
+useXhr = (masterConfig.useXhr) ||
+text.useXhr;
+//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)) {
+//Using special require.nodeRequire, something added by r.js.
+fs = require.nodeRequire('fs');
+text.get = function (url, callback) {
+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);
+};
+} else if (masterConfig.env === 'xhr' || (!masterConfig.env &&
+text.createXhr())) {
+text.get = function (url, callback, errback) {
+var xhr = text.createXhr();
+xhr.open('GET', url, true);
+//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;
+if (status > 399 && status < 600) {
+//An http 4xx or 5xx error. Signal an error.
+err = new Error(url + ' HTTP status: ' + status);
+err.xhr = xhr;
+errback(err);
+} else {
+callback(xhr.responseText);
+}
+}
+};
+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);
+}
+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);
+};
+}
+return text;
+});