1 files changed, 2080 insertions, 0 deletions

diff --git a/point/libs/requirejs/require.js b/point/libs/requirejs/require.js
new file mode 100644
index 0000000..f3a55b2
--- /dev/null
+++ b/point/libs/requirejs/require.js
@@ -0,0 +1,2080 @@
+/** vim: et:ts=4:sw=4:sts=4
+ * @license RequireJS 2.1.14 Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+//Not using strict: uneven strict support in browsers, #392, and causes
+//problems with requirejs.exec()/transpiler plugins that may not be strict.
+/*jslint regexp: true, nomen: true, sloppy: true */
+/*global window, navigator, document, importScripts, setTimeout, opera */
+
+var requirejs, require, define;
+(function (global) {
+        var req, s, head, baseElement, dataMain, src,
+                interactiveScript, currentlyAddingScript, mainScript, subPath,
+                version = '2.1.14',
+                commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
+                cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
+                jsSuffixRegExp = /\.js$/,
+                currDirRegExp = /^\.\//,
+                op = Object.prototype,
+                ostring = op.toString,
+                hasOwn = op.hasOwnProperty,
+                ap = Array.prototype,
+                apsp = ap.splice,
+                isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
+                isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
+        //PS3 indicates loaded and complete, but need to wait for complete
+        //specifically. Sequence is 'loading', 'loaded', execution,
+        // then 'complete'. The UA check is unfortunate, but not sure how
+        //to feature test w/o causing perf issues.
+                readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
+                        /^complete$/ : /^(complete|loaded)$/,
+                defContextName = '_',
+        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
+                isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
+                contexts = {},
+                cfg = {},
+                globalDefQueue = [],
+                useInteractive = false;
+
+        function isFunction(it) {
+                return ostring.call(it) === '[object Function]';
+        }
+
+        function isArray(it) {
+                return ostring.call(it) === '[object Array]';
+        }
+
+        /**
+         * Helper function for iterating over an array. If the func returns
+         * a true value, it will break out of the loop.
+         */
+        function each(ary, func) {
+                if (ary) {
+                        var i;
+                        for (i = 0; i < ary.length; i += 1) {
+                                if (ary[i] && func(ary[i], i, ary)) {
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        /**
+         * Helper function for iterating over an array backwards. If the func
+         * returns a true value, it will break out of the loop.
+         */
+        function eachReverse(ary, func) {
+                if (ary) {
+                        var i;
+                        for (i = ary.length - 1; i > -1; i -= 1) {
+                                if (ary[i] && func(ary[i], i, ary)) {
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        function hasProp(obj, prop) {
+                return hasOwn.call(obj, prop);
+        }
+
+        function getOwn(obj, prop) {
+                return hasProp(obj, prop) && obj[prop];
+        }
+
+        /**
+         * Cycles over properties in an object and calls a function for each
+         * property value. If the function returns a truthy value, then the
+         * iteration is stopped.
+         */
+        function eachProp(obj, func) {
+                var prop;
+                for (prop in obj) {
+                        if (hasProp(obj, prop)) {
+                                if (func(obj[prop], prop)) {
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        /**
+         * Simple function to mix in properties from source into target,
+         * but only if target does not already have a property of the same name.
+         */
+        function mixin(target, source, force, deepStringMixin) {
+                if (source) {
+                        eachProp(source, function (value, prop) {
+                                if (force || !hasProp(target, prop)) {
+                                        if (deepStringMixin && typeof value === 'object' && value && !isArray(value) && !isFunction(value) && !(value instanceof RegExp)) {
+
+                                                if (!target[prop]) {
+                                                        target[prop] = {};
+                                                }
+                                                mixin(target[prop], value, force, deepStringMixin);
+                                        } else {
+                                                target[prop] = value;
+                                        }
+                                }
+                        });
+                }
+                return target;
+        }
+
+        //Similar to Function.prototype.bind, but the 'this' object is specified
+        //first, since it is easier to read/figure out what 'this' will be.
+        function bind(obj, fn) {
+                return function () {
+                        return fn.apply(obj, arguments);
+                };
+        }
+
+        function scripts() {
+                return document.getElementsByTagName('script');
+        }
+
+        function defaultOnError(err) {
+                throw err;
+        }
+
+        //Allow getting a global that is expressed in
+        //dot notation, like 'a.b.c'.
+        function getGlobal(value) {
+                if (!value) {
+                        return value;
+                }
+                var g = global;
+                each(value.split('.'), function (part) {
+                        g = g[part];
+                });
+                return g;
+        }
+
+        /**
+         * Constructs an error with a pointer to an URL with more information.
+         * @param {String} id the error ID that maps to an ID on a web page.
+         * @param {String} message human readable error.
+         * @param {Error} [err] the original error, if there is one.
+         *
+         * @returns {Error}
+         */
+        function makeError(id, msg, err, requireModules) {
+                var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
+                e.requireType = id;
+                e.requireModules = requireModules;
+                if (err) {
+                        e.originalError = err;
+                }
+                return e;
+        }
+
+        if (typeof define !== 'undefined') {
+                //If a define is already in play via another AMD loader,
+                //do not overwrite.
+                return;
+        }
+
+        if (typeof requirejs !== 'undefined') {
+                if (isFunction(requirejs)) {
+                        //Do not overwrite an existing requirejs instance.
+                        return;
+                }
+                cfg = requirejs;
+                requirejs = undefined;
+        }
+
+        //Allow for a require config object
+        if (typeof require !== 'undefined' && !isFunction(require)) {
+                //assume it is a config object.
+                cfg = require;
+                require = undefined;
+        }
+
+        function newContext(contextName) {
+                var inCheckLoaded, Module, context, handlers,
+                        checkLoadedTimeoutId,
+                        config = {
+                                //Defaults. Do not set a default for map
+                                //config to speed up normalize(), which
+                                //will run faster if there is no default.
+                                waitSeconds: 7,
+                                baseUrl: './',
+                                paths: {},
+                                bundles: {},
+                                pkgs: {},
+                                shim: {},
+                                config: {}
+                        },
+                        registry = {},
+                //registry of just enabled modules, to speed
+                //cycle breaking code when lots of modules
+                //are registered, but not activated.
+                        enabledRegistry = {},
+                        undefEvents = {},
+                        defQueue = [],
+                        defined = {},
+                        urlFetched = {},
+                        bundlesMap = {},
+                        requireCounter = 1,
+                        unnormalizedCounter = 1;
+
+                /**
+                 * Trims the . and .. from an array of path segments.
+                 * It will keep a leading path segment if a .. will become
+                 * the first path segment, to help with module name lookups,
+                 * which act like paths, but can be remapped. But the end result,
+                 * all paths that use this function should look normalized.