First versionHEADmaster

1 files changed, 389 insertions, 0 deletions

diff --git a/point/libs/text/text.js b/point/libs/text/text.js
new file mode 100644
index 0000000..2748bed
--- /dev/null
+++ b/point/libs/text/text.js
@@ -0,0 +1,389 @@
+/**
+ * @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';
+