From b89a7ee8b956c96a1dcee995ea840feddc5d4b27 Mon Sep 17 00:00:00 2001
From: Pierre Frisch
Date: Thu, 22 Dec 2011 07:25:50 -0800
Subject: First commit of Ninja to ninja-internal

Signed-off-by: Valerio Virgillito <rmwh84@motorola.com>
---
 node_modules/montage/core/shim/array.js      |  78 ++++
 node_modules/montage/core/shim/string.js     |  66 ++++
 node_modules/montage/core/shim/structures.js | 552 +++++++++++++++++++++++++++
 node_modules/montage/core/shim/timers.js     |  87 +++++
 node_modules/montage/core/shim/weak-map.js   | 454 ++++++++++++++++++++++
 5 files changed, 1237 insertions(+)
 create mode 100755 node_modules/montage/core/shim/array.js
 create mode 100755 node_modules/montage/core/shim/string.js
 create mode 100755 node_modules/montage/core/shim/structures.js
 create mode 100755 node_modules/montage/core/shim/timers.js
 create mode 100755 node_modules/montage/core/shim/weak-map.js

(limited to 'node_modules/montage/core/shim')

diff --git a/node_modules/montage/core/shim/array.js b/node_modules/montage/core/shim/array.js
new file mode 100755
index 00000000..ff5d5d37
--- /dev/null
+++ b/node_modules/montage/core/shim/array.js
@@ -0,0 +1,78 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+/**
+    Defines extensions to native Array object.
+    @see [Array class]{@link external:Array}
+    @module montage/core/shim/array
+*/
+/**
+    @external Array
+*/
+
+/**
+    @function external:Array#equals
+    @param {object} right The object to compare.
+    @returns {Boolean} true or false
+*/
+if (!Array.prototype.equals) {
+    Object.defineProperty(Array.prototype, "equals", {
+        value: function (right) {
+            var i = 0,
+                length = this.length,
+                lhs,
+                rhs;
+
+            if (this === right) {
+                return true;
+            }
+
+            if (!right || !Array.isArray(right)) {
+                return false;
+            }
+
+            if (length !== right.length) {
+                return false;
+            } else {
+                for (; i < length; ++i) {
+                    if (i in this) {
+                        lhs = this[i],
+                            rhs = right[i];
+
+                        if (lhs !== rhs && (lhs && rhs && !lhs.equals(rhs))) {
+                            return false;
+                        }
+                    } else {
+                        if (i in right) {
+                            return false;
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+    });
+}
+/**
+    Shim implementation of Array.isArray() for browsers that don't yet support it.
+    @function external:Array.isArray
+    @param {object} obj The object to determine if its an array.
+    @returns {Array} Object.prototype.toString.call(obj) === "[object Array]"
+*/
+if (!Array.isArray) {
+    Object.defineProperty(Array, "isArray", {
+        value: function(obj) {
+            return Object.prototype.toString.call(obj) === "[object Array]";
+        }
+    });
+}
+
+if (!Array.isCanvasPixelArray) {
+    Object.defineProperty(Array, "isCanvasPixelArray", {
+        value: function(obj) {
+            return Object.prototype.toString.call(obj) === "[object CanvasPixelArray]";
+        }
+    });
+}
diff --git a/node_modules/montage/core/shim/string.js b/node_modules/montage/core/shim/string.js
new file mode 100755
index 00000000..1b71cec3
--- /dev/null
+++ b/node_modules/montage/core/shim/string.js
@@ -0,0 +1,66 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+/**
+    Defines extensions to native String object.
+    @see [String class]{@link external:String}
+	@module montage/core/shim/string
+*/
+
+/**
+ @external String
+ */
+Object.defineProperties(String.prototype, /** @lends external:String.prototype#*/{
+    /**
+    @function external:String.addEventListener
+    @param {Listener} type The type of event listener.
+    @param {Listener} listener The event listener.
+    @param {Function} useCapture The capturing function.
+    */
+    addEventListener: {
+        value: function(type, listener, useCapture) {
+            //NO OP, on purpose
+        }
+
+    },
+    /**
+     Capitalizes the first letter in the string.
+     @function external:String.toCapitalized
+     @returns {String} The original string with its first letter capitalized.
+     @example
+     var fname = "abe";
+     var lname = "lincoln";
+     var name = fname.toCapitalized() + " " + lname.toCapitalized();
+     // name == "Abe Lincoln"
+     */
+    toCapitalized: {
+        value: function() {
+            return this.charAt(0).toUpperCase() + this.slice(1);
+        }
+    },
+
+    /**
+     Returns true if the two strings are equal, otherwise returns false.
+     @function external:String.equals
+     @param {Object} anObject The object to compare to the string.
+     @returns {Boolean} Returns true if the string is equal to <code>anObject</code>.
+     */
+    equals: {
+        value: function(anObject) {
+            if (this.toString() === anObject) {
+                return true;
+            }
+
+            if (!anObject || !(anObject instanceof String)) {
+                return false;
+            }
+
+            return (this == anObject);
+        }
+    }
+
+});
+
+
diff --git a/node_modules/montage/core/shim/structures.js b/node_modules/montage/core/shim/structures.js
new file mode 100755
index 00000000..2f3d7d05
--- /dev/null
+++ b/node_modules/montage/core/shim/structures.js
@@ -0,0 +1,552 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+// Specification:
+// http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets
+
+/**
+ This module provides common data structure utililties, such as maps and sets.
+ @module montage/core/shim/structures
+ @see [Map class]{@link module:montage/core/shim/structures.Map}
+ */
+/**
+ @class module:montage/core/shim/structures.Map
+ @classdesc Provides a Map data structure for managing key/value pairs, including methods for querying and manipulating map elements. A map cannot contain duplicate keys; each key can map to at most one value.
+ */
+exports.Map = Map;
+function Map(ignored, options) {
+    if (!(this instanceof Map)) {
+        return new Map(ignored, options);
+    }
+    options = options || {};
+    var eq = options.eq || Set.eq;
+    var hash = options.hash || Set.hash;
+    this._set = Set(
+        undefined,
+        {
+            eq: function (a, b) {
+                return eq(a.key, b.key);
+            },
+            hash: function (pair) {
+                return hash(pair.key);
+            }
+        }
+    );
+}
+
+Object.defineProperties(Map.prototype, /** @lends module:montage/core/shim/structures.Map# */ {
+/**
+    @function
+    @returns this._set.empty()
+    */
+    empty: {
+        value: function () {
+            return this._set.empty();
+        }
+    },
+
+    /**
+     Returns the value associated with the <code>key</code> parameter, if it exists.
+     @function
+     @param {String} key The name of the key.
+     @returns {Object} The value of the specified key, if it exists; otherwise returns undefined.
+     */
+    get: {
+        value: function (key) {
+            var pair = this._set.get({
+                key: key
+            });
+            return pair ? pair.value : undefined;
+        }
+    },
+
+    /**
+     Adds a new key/value pair to the map.
+     @function
+     @param {Object} key The key to use for the new pair.
+     @param {Object} value The value to associate with the key.
+     @returns key, value
+     */
+    set: {
+        value: function (key, value) {
+            return this._set.add({
+                key: key,
+                value: value
+            });
+        }
+    },
+
+    /**
+     Deletes the element from the map specified by the <code>key</code> parameter.
+     @function
+     @param {Object} key The key of the map element to remove.
+     @returns key
+     */
+
+    "delete": { // née del
+        value: function (key) {
+            return this._set["delete"]({
+                key: key
+            });
+        }
+    },
+
+    /**
+     Returns true if the map contains an element with the specified key, otherwise returns false.
+     @function
+     @param {Object} key The key of the element you want to query for.
+     @returns {Boolean} Returns <code>true</code> if the map contains the specified key, otherwise returns <code>false</code>.
+     */
+    has: {
+        value: function (key) {
+            return this._set.has({
+                key: key
+            });
+        }
+    },
+
+    /**
+     Executes a function once per map element, passing the current element to each function as a parameter.
+     @function
+     @param {Function} callback The function to execute for each element.
+     */
+
+    forEach: {
+        value: function (callback /*, thisp*/) {
+            var self = Object(this),
+                thisp = arguments[1];
+            return this._set.forEach(function (pair) {
+                callback.call(thisp, pair.value, pair.key, self);
+            });
+        }
+    }
+});
+
+/**
+ Provides a set data structure and methods to query and modify the set.<br>
+ A set is a collection that contains no duplicate elements. It stores<br>
+ @class module:montage/core/shim/structures.Set
+ */
+exports.Set = Set;
+function Set(ignored, options) {
+    if (!(this instanceof Set)) {
+        return new Set(ignored, options);
+    }
+    options = options || {};
+    var eq = options.eq || Set.eq;
+    var hash = options.hash || Set.hash;
+    this._buckets = {};
+    this._Bucket = function () {
+        return OrderedSet(undefined, {
+            eq: eq
+        });
+    };
+    this._eq = eq;
+    this._hash = hash;
+}
+
+Object.defineProperties(Set.prototype, /** @lends module:montage/core/shim/structures.Set# */ {
+    /**
+     Determines if the set is empty or not.
+     @function
+     @returns {Boolean} Returns <code>true</code> if the set is empty, otherwise returns <code>false</code>.
+     */
+    empty: {
+        value: function () {
+            return !Object.keys(this._buckets).length;
+        }
+    },
+
+    /**
+     Retrieves the value of the specified set element.
+     @function
+     @param {Object} value The key to an element in the set.
+     */
+    get: {
+        value: function (value) {
+            var hash = this._hash(value);
+            var buckets = this._buckets;
+            return buckets[hash] ? buckets[hash].get(value) : undefined;
+        }
+    },
+
+    /**
+     Determines if the set contains a specified item.
+     @function
+     @param {Number} value
+     @returns {Object} The value of the set element.
+     */
+    has: {
+        value: function (value) {
+            var hash = this._hash(value);
+            var buckets = this._buckets;
+            return buckets[hash] ? buckets[hash].has(value) : false;
+        }
+    },
+
+    /**
+     Inserts a new element into the set with <code>value</code> as the hash key.
+     @function
+     @param {String} value The new element's hash key.
+     */
+    add: { // née insert
+        value: function (value) {
+            var hash = this._hash(value);
+            var buckets = this._buckets;
+            var bucket = buckets[hash] = buckets[hash] || this._Bucket();
+            bucket.add(value);
+        }
+    },
+
+    /**
+     Removes an element from the set identified by the specified hash key.
+     @function
+     @param {String} value The hash key of the element to remove.
+     */
+    "delete": { // née remove
+        value: function (value) {
+            var hash = this._hash(value);
+            var buckets = this._buckets;
+            var bucket = buckets[hash] = buckets[hash] || this._Bucket();
+            bucket["delete"](value);
+            if (bucket.empty()) {
+                delete buckets[hash];
+            }
+        }
+    },
+
+    /**
+     Executes a function once per set element.
+     @function
+     @param {Function} callback The function to execute on each element.
+     @returns {Object} object
+     */
+
+    forEach: {
+        value: function (callback /*, thisp*/) {
+            var self = Object(this);
+            var thisp = arguments[1];
+            var buckets = self._buckets;
+            return Object.keys(buckets).forEach(function (hash) {
+                buckets[hash].forEach(callback, thisp);
+            });
+        }
+    }
+});
+/**
+    @class module:montage/core/shim/structures.OrderedSet
+    @param {boolean} ignored
+    @param {object} options
+*/
+exports.OrderedSet = OrderedSet;
+function OrderedSet(ignored, options) {
+    if (!(this instanceof OrderedSet)) {
+        return new OrderedSet(ignored, options);
+    }
+    options = options || {};
+    var eq = options.eq || OrderedSet.eq;
+    var head = {};
+    head.next = head;
+    head.prev = head;
+    this._head = head;
+    this._eq = eq;
+}
+;
+/**
+  @private
+*/
+Object.defineProperties(OrderedSet.prototype, /** @lends module:montage/core/shim/structures.OrderedSet */{
+    _delete: {
+        value: function (node) {
+            node.prev.next = node.next;
+            node.next.prev = node.prev;
+        }
+    },
+
+    _add: {
+        value: function (node) {
+            var head = this._head;
+            var prev = head.prev;
+            head.prev = node;
+            node.prev = prev;
+            prev.next = node;
+            node.next = head;
+        }
+    },
+
+    _find: {
+        value: function (value) {
+            var head = this._head;
+            var at = head.next;
+            while (at !== head) {
+                if (this._eq(at.data, value)) {
+                    return at;
+                }
+                at = at.next;
+            }
+        }
+    },
+
+    /**
+    @function
+    @returns {boolean} Returns <code>true</code> if empty, otherwise returns <code>false</code>
+    */
+    empty: {
+        value: function () {
+            var head = this._head;
+            return head.next === head;
+        }
+    },
+    /**
+    @function
+    @param {Number} value
+    @returns !!this._find(value)
+    */
+    has: {
+        value: function (value) {
+            return !!this._find(value);
+        }
+    },
+    /**
+    @function
+    @param {Number} value
+    @returns found.data
+    */
+    get: {
+        value: function (value) {
+            var found = this._find(value);
+            if (found) {
+                return found.data;
+            }
+        }
+    },
+   /**
+    @function
+    @param {Number} value
+    */
+    add: { // née insert
+        value: function (value) {
+            if (!this._find(value)) {
+                this._add({
+                    data: value
+                });
+            }
+        }
+    },
+  /**
+    @function
+    @param {Number} value
+    */
+    "delete": { // née remove
+        value: function (value) {
+            var found = this._find(value);
+            if (found) {
+                this._delete(found);
+            }
+        }
+    },
+   /**
+    @function
+    @param {Function} callback The callback function.
+    @param {String} context The context string.
+    */
+    forEach: {
+        value: function (callback, context) {
+            var head = this._head;
+            var at = head.next;
+            while (at !== head) {
+                callback.call(context, at.data);
+                at = at.next;
+            }
+        }
+    }
+});
+
+Set.eq =
+    OrderedSet.eq = function (a, b) {
+        return a === b;
+    };
+
+/**
+    @function
+    @param {String} value
+    @returns "~"
+    */
+Set.hash = function (value) {
+    return "~" + (
+        value && typeof value.hash === "function" ?
+            value.hash() :
+            value
+        );
+};
+
+// A least-recently-used cache map contains an entagled
+// linked list and mapping.  The mapping serves to provide
+// constant-time access to any of the linked list nodes.
+// When nodes are accessed, they float to the top of the
+// list. The least recently accessed node will be collected
+// when the collection size exceeds the maximum length.
+//
+// A WeakMap is almost always a superior alternative to
+// a CacheMap, but a CacheMap will suffice in some cases
+// if the former is not available.
+
+/**
+    @exports CacheMap
+    @function
+    @param {Boolean} ignored
+    @param {String} options
+    @returns new CacheMap(ignored, options)
+    */
+exports.CacheMap = CacheMap;
+function CacheMap(ignored, options) {
+    if (!(this instanceof CacheMap)) {
+        return new CacheMap(ignored, options);
+    }
+    options = options || {};
+
+    this._set = new OrderedSet(undefined, options);
+    this._map = new Map(undefined, options);
+
+    this._length = 0;
+    this._maxLength = options.maxLength || Infinity;
+    this._ondrop = options.ondrop;
+}
+
+/**
+    @class module:montage/core/shim/structures.CacheMap
+*/
+CacheMap.prototype = Object.create(Object.prototype,/** @lends module:montage/core/shim/structures.CacheMap# */ {
+    /**
+            @type {Constructor}
+        @default CacheMap
+    */
+    constructor: {
+        value: CacheMap
+    },
+/**
+  @private
+*/
+    _add: {
+        value: function (node) {
+            this._map.set(node.key, node);
+            this._set.add(node);
+            this._length++;
+            if (this._length > this._maxLength) {
+                // delete least recently accessed node
+                // /!\ dives deep into set structure
+                var node = this._set._head.next;
+                if (this._ondrop) {
+                    this._ondrop(node.data);
+                }
+                this._set._delete(node);
+                this._map["delete"](node.key);
+                this._length--;
+            }
+        }
+    },
+ /**
+  @private
+*/
+    _delete: {
+        value: function (node) {
+            this._map["delete"](node.key);
+            this._set["delete"](node);
+            this._length--;
+        }
+    },
+ /**
+    @function
+    @returns this._set.empty()
+    */
+    empty: {
+        value: function () {
+            return this._set.empty();
+        }
+    },
+   /**
+    @function
+    @param {Function} key
+    @returns node.value
+    */
+    get: {
+        value: function (key) {
+            var node = this._map.get(key);
+            if (!node) {
+                return;
+            }
+            // push node to tail
+            this._set["delete"](node);
+            this._set.add(node);
+            return node.value;
+        }
+    },
+    /**
+    @function
+    @param {String} key
+    @param {Number} value
+    */
+    set: {
+        value: function (key, value) {
+            var node = this._map.get(key);
+            if (node) {
+                node.value = value;
+                this._delete(node);
+            } else {
+                node = {
+                    key: key,
+                    value: value
+                };
+            }
+            this._add(node);
+        }
+    },
+    /**
+    @function
+    @param {String} key
+    */
+    "delete": {
+        value: function (key) {
+            var node = this._map.get(key);
+            if (node) {
+                this._delete(node);
+            }
+        }
+    },
+    /**
+    @function
+    @param {String} key
+    @returns this._map.has(key)
+    */
+    has: {
+        value: function (key) {
+            return this._map.has(key);
+        }
+    },
+   /**
+    @function
+    @returns {Array} keys
+    */
+    keys: {
+        value: function () {
+            var keys = [];
+            this._set.forEach(function (node) {
+                keys.push(node.key);
+            });
+            return keys;
+        }
+    },
+    /**
+    @function
+    @returns this._set.forEach.apply(this._set, arguments)
+    */
+    forEach: {
+        value: function () {
+            return this._set.forEach.apply(this._set, arguments);
+        }
+    }
+});
+
diff --git a/node_modules/montage/core/shim/timers.js b/node_modules/montage/core/shim/timers.js
new file mode 100755
index 00000000..859a7aec
--- /dev/null
+++ b/node_modules/montage/core/shim/timers.js
@@ -0,0 +1,87 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+ /**
+    Defines [setImmediate()]{@link setImmediate} and [clearImmediate()]{@link clearImmediate} shim functions.
+    @see setImmediate
+    @see clearImmediate
+    @module montage/core/shim/timers
+ */
+
+/**
+    @function
+    @name setImmediate
+    @global
+*/
+
+/**
+    @function
+    @name clearImmediate
+    @global
+*/
+
+(function (global) {
+
+var nextTick;
+if (typeof process !== "undefined") {
+    nextTick = process.nextTick;
+} else if (typeof MessageChannel !== "undefined") {
+    // http://www.nonblocking.io/2011/06/windownexttick.html
+    var channel = new MessageChannel();
+    // linked list of tasks (single, with head node)
+    var head = {}, tail = head;
+
+    channel.port1.onmessage = function () {
+        var next = head.next;
+        var task = next.task;
+        head = next;
+        task();
+    };
+
+    nextTick = function (task) {
+        tail = tail.next = {task: task};
+        channel.port2.postMessage(void 0);
+    }
+} else if (typeof setTimeout !== "undefined") {
+
+    nextTick = function (callback) {
+        setTimeout(callback, 0);
+    };
+} else {
+    throw new Error("Can't shim setImmediate.");
+}
+
+if (typeof setImmediate === "undefined") {
+    var nextHandle = 0;
+    var handles = {};
+
+
+    global.setImmediate = function setImmediate(callback) {
+        var handle = nextHandle++;
+        var args = arguments.length > 1 ?
+            Array.prototype.slice.call(arguments, 1) :
+            void 0;
+        handles[handle] = true;
+        nextTick(function () {
+            if (handles[handle]) {
+                callback.apply(void 0, args);
+                delete handles[handle];
+            }
+        });
+        return handle;
+    };
+
+    global.clearImmediate = function clearImmediate(handle) {
+        delete handles[handle];
+    };
+}
+
+// Make this work as a <script> for bootstrapping montage.js
+if (typeof bootstrap !== "undefined") {
+    bootstrap("core/shim/timers", function () {});
+}
+
+})(typeof global === "undefined" ? window : global);
diff --git a/node_modules/montage/core/shim/weak-map.js b/node_modules/montage/core/shim/weak-map.js
new file mode 100755
index 00000000..ae99a60c
--- /dev/null
+++ b/node_modules/montage/core/shim/weak-map.js
@@ -0,0 +1,454 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+/* <notice>
+ Derived from http://code.google.com/p/es-lab/source/browse/trunk/src/ses/WeakMap.js
+ Added the export
+ Removed the check for ses
+// Copyright (C) 2011 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+</notice> */
+
+/**
+ * @fileoverview Install a leaky WeakMap emulation on platforms that
+ * don't provide a built-in one.
+ *
+ * <p>Assumes that an ES5 platform where, if {@code WeakMap} is
+ * already present, then it conforms to the anticipated ES6
+ * specification. To run this file on an ES5 or almost ES5
+ * implementation where the {@code WeakMap} specification does not
+ * quite conform, run <code>repairES5.js</code> first.
+ *
+ * @author Mark S. Miller
+ * @requires ses
+ * @overrides WeakMap
+ */
+
+/**
+  @module montage/core/shim/weak-map
+*/
+
+ /**
+  * This {@code WeakMap} emulation is observably equivalent to the
+ * ES-Harmony WeakMap, but with leakier garbage collection properties.
+ *
+ * As with true WeakMaps, in this emulation, a key does not
+ * retain maps indexed by that key and (crucially) a map does not
+ * retain the keys it indexes. A map by itself also does not retain
+ * the values associated with that map.
+ *
+<p>However, the values associated with a key in some map are
+ * retained so long as that key is retained and those associations are
+ * not overridden. For example, when used to support membranes, all
+ * values exported from a given membrane will live for the lifetime
+ * they would have had in the absence of an interposed membrane. Even
+ * when the membrane is revoked, all objects that would have been
+ * reachable in the absence of revocation will still be reachable, as
+ * far as the GC can tell, even though they will no longer be relevant
+ * to ongoing computation.
+ *
+ * <p>The API implemented here is approximately the API as implemented
+ * in FF6.0a1 and agreed to by MarkM, Andreas Gal, and Dave Herman,
+ * rather than the offially approved proposal page. TODO(erights):
+ * upgrade the ecmascript WeakMap proposal page to explain this API
+ * change and present to EcmaScript committee for their approval.
+ *
+<p>The first difference between the emulation here and that in
+ * FF6.0a1 is the presence of non enumerable {@code get___, has___,
+ * set___, and delete___} methods on WeakMap instances to represent
+ * what would be the hidden internal properties of a primitive
+ * implementation. Whereas the FF6.0a1 WeakMap.prototype methods
+ * require their {@code this} to be a genuine WeakMap instance (i.e.,
+ * an object of {@code [[Class]]} "WeakMap}), since there is nothing
+ * unforgeable about the pseudo-internal method names used here,
+ * nothing prevents these emulated prototype methods from being
+ * applied to non-WeakMaps with pseudo-internal methods of the same
+ * names.
+ *
+ * <p>Another difference is that our emulated {@code
+ * WeakMap.prototype} is not itself a WeakMap. A problem with the
+ * current FF6.0a1 API is that WeakMap.prototype is itself a WeakMap
+ * providing ambient mutability and an ambient communications
+ * channel. Thus, if a WeakMap is already present and has this
+ * problem, repairES5.js wraps it in a safe wrappper in order to
+ * prevent access to this channel. (See
+ * PATCH_MUTABLE_FROZEN_WEAKMAP_PROTO in repairES5.js).
+ @class module:montage/core/shim/weak-map.WeakMap
+ */
+
+var WeakMap;
+
+/**
+ * If this is a full <a href=
+ * "http://code.google.com/p/es-lab/wiki/SecureableES5"
+ * >secureable ES5</a> platform and the ES-Harmony {@code WeakMap} is
+ * absent, install an approximate emulation.
+ *
+ * <p>If this is almost a secureable ES5 platform, then WeakMap.js
+ * should be run after repairES5.js.
+ *
+ * <p>See {@code WeakMap} for documentation of the garbage collection
+ * properties of this WeakMap emulation.
+ */
+(function() {
+  "use strict";
+
+//  if (typeof ses !== 'undefined' && ses.ok && !ses.ok()) {
+//    // already too broken, so give up
+//    return;
+//  }
+
+  if (typeof WeakMap === 'function') {
+    // assumed fine, so we're done.
+    return;
+  }
+
+  var hop = Object.prototype.hasOwnProperty;
+  var gopn = Object.getOwnPropertyNames;
+  var defProp = Object.defineProperty;
+
+  /**
+   * Holds the orginal static properties of the Object constructor,
+   * after repairES5 fixes these if necessary to be a more complete
+   * secureable ES5 environment, but before installing the following
+   * WeakMap emulation overrides and before any untrusted code runs.
+   */
+  var originalProps = {};
+  gopn(Object).forEach(function(name) {
+    originalProps[name] = Object[name];
+  });
+
+  /**
+   * Security depends on HIDDEN_NAME being both <i>unguessable</i> and
+   * <i>undiscoverable</i> by untrusted code.
+   *
+   * <p>Given the known weaknesses of Math.random() on existing
+   * browsers, it does not generate unguessability we can be confident
+   * of. TODO(erights): Detect crypto.getRandomValues and if there,
+   * use it instead.
+   *
+   * <p>It is the monkey patching logic in this file that is intended
+   * to ensure undiscoverability. The basic idea is that there are
+   * three fundamental means of discovering properties of an object:
+   * The for/in loop, Object.keys(), and Object.getOwnPropertyNames(),
+   * as well as some proposed ES6 extensions that appear on our
+   * whitelist. The first two only discover enumerable properties, and
+   * we only use HIDDEN_NAME to name a non-enumerable property, so the
+   * only remaining threat should be getOwnPropertyNames and some
+   * proposed ES6 extensions that appear on our whitelist. We monkey
+   * patch them to remove HIDDEN_NAME from the list of properties they
+   * returns.
+   */
+  var HIDDEN_NAME = 'ident:' + Math.random() + '___';
+
+  /**
+   * Monkey patch getOwnPropertyNames to avoid revealing the
+   * HIDDEN_NAME.
+   *
+   * <p>The ES5.1 spec requires each name to appear only once, but as
+   * of this writing, this requirement is controversial for ES6, so we
+   * made this code robust against this case. If the resulting extra
+   * search turns out to be expensive, we can probably relax this once
+   * ES6 is adequately supported on all major browsers, iff no browser
+   * versions we support at that time have relaxed this constraint
+   * without providing built-in ES6 WeakMaps.
+   */
+
+  defProp(Object, 'getOwnPropertyNames', {
+    value: function fakeGetOwnPropertyNames(obj) {
+      var result = gopn(obj);
+      var i = 0;
+      while ((i = result.indexOf(HIDDEN_NAME, i)) >= 0) {
+        result.splice(i, 1);
+      }
+      return result;
+    }
+  });
+
+  /**
+   getPropertyNames is not in ES5 but it is proposed for ES6 and<br>
+   does appear in our whitelist, so we need to clean it too.
+   */
+
+
+  if ('getPropertyNames' in Object) {
+    defProp(Object, 'getPropertyNames', {
+      value: function fakeGetPropertyNames(obj) {
+        var result = originalProps.getPropertyNames(obj);
+        var i = 0;
+        while ((i = result.indexOf(HIDDEN_NAME, i)) >= 0) {
+          result.splice(i, 1);
+        }
+        return result;
+      }
+    });
+  }
+
+  /**
+   * <p>To treat objects as identity-keys with reasonable efficiency
+   * on ES5 by itself (i.e., without any object-keyed collections), we
+   * need to add a hidden property to such key objects when we
+   * can. This raises several issues:
+   * <ul>
+   * <li>Arranging to add this property to objects before we lose the
+   *     chance, and
+   * <li>Hiding the existence of this new property from most
+   *     JavaScript code.
+   * <li>Preventing <i>certification theft</i>, where one object is
+   *     created falsely claiming to be the key of an association
+   *     actually keyed by another object.
+   * <li>Preventing <i>value theft</i>, where untrusted code with
+   *     access to a key object but not a weak map nevertheless
+   *     obtains access to the value associated with that key in that
+   *     weak map.
+   * </ul>
+   * We do so by
+   * <ul>
+   * <li>Making the name of the hidden property unguessable, so "[]"
+   *     indexing, which we cannot intercept, cannot be used to access
+   *     a property without knowing the name.
+   * <li>Making the hidden property non-enumerable, so we need not
+   *     worry about for-in loops or {@code Object.keys},
+   * <li>monkey patching those reflective methods that would
+   *     prevent extensions, to add this hidden property first,
+   * <li>monkey patching those methods that would reveal this
+   *     hidden property.
+   * </ul>
+   * Unfortunately, because of same-origin iframes, we cannot reliably
+   * add this hidden property before an object becomes
+   * non-extensible. Instead, if we encounter a non-extensible object
+   * without a hidden record that we can detect (whether or not it has
+   * a hidden record stored under a name secret to us), then we just
+   * use the key object itself to represent its identity in a brute
+   * force leaky map stored in the weak map, losing all the advantages
+   * of weakness for these.
+   */
+  function getHiddenRecord(key) {
+    if (key !== Object(key)) {
+      throw new TypeError('Not an object: ' + key);
+    }
+    var hiddenRecord = key[HIDDEN_NAME];
+    if (hiddenRecord && hiddenRecord.key === key) { return hiddenRecord; }
+    if (!originalProps.isExtensible(key)) {
+      // Weak map must brute force, as explained in doc-comment above.
+      return void 0;
+    }
+    var gets = [];
+    var vals = [];
+    hiddenRecord = {
+      key: key,   // self pointer for quick own check above.
+      gets: gets, // get___ methods identifying weak maps
+      vals: vals  // values associated with this key in each
+                  // corresponding weak map.
+    };
+    defProp(key, HIDDEN_NAME, {
+      value: hiddenRecord,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    return hiddenRecord;
+  }
+
+
+  /**
+   * Monkey patch operations that would make their argument
+   * non-extensible.
+   *
+   * <p>The monkey patched versions throw a TypeError if their
+   * argument is not an object, so it should only be done to functions
+   * that should throw a TypeError anyway if their argument is not an
+   * object.
+   */
+  (function(){
+    var oldFreeze = Object.freeze;
+    defProp(Object, 'freeze', {
+      value: function identifyingFreeze(obj) {
+        getHiddenRecord(obj);
+        return oldFreeze(obj);
+      }
+    });
+    var oldSeal = Object.seal;
+    defProp(Object, 'seal', {
+      value: function identifyingSeal(obj) {
+        getHiddenRecord(obj);
+        return oldSeal(obj);
+      }
+    });
+    var oldPreventExtensions = Object.preventExtensions;
+    defProp(Object, 'preventExtensions', {
+      value: function identifyingPreventExtensions(obj) {
+        getHiddenRecord(obj);
+        return oldPreventExtensions(obj);
+      }
+    });
+  })();
+
+
+  function constFunc(func) {
+    Object.freeze(func.prototype);
+    return Object.freeze(func);
+  }
+
+  WeakMap = function() {
+    var keys = []; // brute force for prematurely non-extensible keys.
+    var vals = []; // brute force for corresponding values.
+
+    function get___(key, opt_default) {
+      var hr = getHiddenRecord(key);
+      var i, vs;
+      if (hr) {
+        i = hr.gets.indexOf(get___);
+        vs = hr.vals;
+      } else {
+        i = keys.indexOf(key);
+        vs = vals;
+      }
+      return (i >= 0) ? vs[i] : opt_default;
+    }
+
+    function has___(key) {
+      var hr = getHiddenRecord(key);
+      var i;
+      if (hr) {
+        i = hr.gets.indexOf(get___);
+      } else {
+        i = keys.indexOf(key);
+      }
+      return i >= 0;
+    }
+
+    function set___(key, value) {
+      var hr = getHiddenRecord(key);
+      var i;
+      if (hr) {
+        i = hr.gets.indexOf(get___);
+        if (i >= 0) {
+          hr.vals[i] = value;
+        } else {
+          hr.gets.push(get___);
+          hr.vals.push(value);
+        }
+      } else {
+        i = keys.indexOf(key);
+        if (i >= 0) {
+          vals[i] = value;
+        } else {
+          keys.push(key);
+          vals.push(value);
+        }
+      }
+    }
+
+    function delete___(key) {
+      var hr = getHiddenRecord(key);
+      var i;
+      if (hr) {
+        i = hr.gets.indexOf(get___);
+        if (i >= 0) {
+          hr.gets.splice(i, 1);
+          hr.vals.splice(i, 1);
+        }
+      } else {
+        i = keys.indexOf(key);
+        if (i >= 0) {
+          keys.splice(i, 1);
+          vals.splice(i, 1);
+        }
+      }
+      return true;
+    }
+
+    return Object.create(WeakMap.prototype, {
+      get___:    { value: constFunc(get___) },
+      has___:    { value: constFunc(has___) },
+      set___:    { value: constFunc(set___) },
+      delete___: { value: constFunc(delete___) }
+    });
+  };
+
+  WeakMap.prototype = Object.create(Object.prototype, /** @lends module:montage/core/shim/weak-map.WeakMap# */ {
+
+
+/**
+ * Returns the value most recently associated with key, or
+ * opt_default if none.
+ * @function
+ * @param {object} key
+ * @param {object} opt_default
+ */
+    get: {
+      value: function get(key, opt_default) {
+        return this.get___(key, opt_default);
+      },
+      writable: true,
+      configurable: true
+    },
+
+/**
+ * Returns <code>true</code> if there is a value associated with the specified key in the WeakMap, otherwise returns <code>false</code>
+ * @function
+ * @param {object} key
+ */
+    has: {
+      value: function has(key) {
+        return this.has___(key);
+      },
+      writable: true,
+      configurable: true
+    },
+
+/**
+ * Associate value with key in this WeakMap, overwriting any
+ * previous association if present.
+ * @function
+ * @param {object} key
+ * @param {object} value
+ */
+    set: {
+      value: function set(key, value) {
+        this.set___(key, value);
+      },
+      writable: true,
+      configurable: true
+    },
+
+/**
+ * Remove any association for key in this WeakMap, returning
+ * whether there was one.
+ * @function
+ * @param {object} key
+ *
+ * FIXME <p>Note that the boolean return here does not work like the
+ * delete operator. The operator returns
+ * whether the deletion succeeds at bringing about a state in
+ * which the deleted property is absent. The delete
+ * operator therefore returns true if the property was already
+ * absent, whereas this {@link delete} method returns false if
+ * the association was already absent.
+ */
+    'delete': {
+      value: function remove(key) {
+        return this.delete___(key);
+      },
+      writable: true,
+      configurable: true
+    }
+  });
+
+})();
+
+exports.WeakMap = WeakMap;
-- 
cgit v1.2.3