/**
* @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;
});

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.