Initial drop of code extracted from express-state

Author: ericf

LICENSE

@@ -0,0 +1,27 @@
+Copyright 2014 Yahoo! Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the Yahoo! Inc. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL YAHOO! INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

index.js

@@ -0,0 +1,81 @@
+/*
+Copyright (c) 2014, Yahoo! Inc. All rights reserved.
+Copyrights licensed under the New BSD License.
+See the accompanying LICENSE file for terms.
+*/
+
+'use strict';
+
+var util = require('util');
+
+module.exports = serialize;
+
+var IS_NATIVE_CODE_REGEX = /\{\s*\[native code\]\s*\}/g,
+    PLACE_HOLDER_REGEX   = /"@__(FUNCTION|REGEXP)_(\d+)__@"/g,
+    UNSAFE_CHARS_REGEX   = /[<>\/\u2028\u2029]/g;
+
+// Mapping of unsafe HTML and invalid JavaScript line terminator chars to their
+// Unicode char counterparts which are safe to use in JavaScript strings.
+var UNICODE_CHARS = {
+    '<'     : '\\u003C',
+    '>'     : '\\u003E',
+    '/'     : '\\u002F',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029'
+};
+
+function serialize(obj) {
+    var functions = [],
+        regexps   = [],
+        str;
+
+    // Creates a JSON string representation of the object and uses placeholders
+    // for functions and regexps (identified by index) which are later
+    // replaced.
+    str = JSON.stringify(obj, function (key, value) {
+        if (typeof value === 'function') {
+            return '@__FUNCTION_' + (functions.push(value) - 1) + '__@';
+        }
+
+        if (util.isRegExp(value)) {
+            return '@__REGEXP_' + (regexps.push(value) - 1) + '__@';
+        }
+
+        return value;
+    });
+
+    // Protects against `JSON.stringify()` returning `undefined`, by serializing
+    // to the literal string: "undefined".
+    if (typeof str !== 'string') {
+        return String(str);
+    }
+
+    // Replace unsafe HTML and invalid JavaScript line terminator chars with
+    // their safe Unicode char counterpart. This _must_ happen before the
+    // regexps and functions are serialized and added back to the string.
+    str = str.replace(UNSAFE_CHARS_REGEX, function (unsafeChar) {
+        return UNICODE_CHARS[unsafeChar];
+    });
+
+    if (!(functions.length || regexps.length)) {
+        return str;
+    }
+
+    // Replaces all occurrences of function and regexp placeholders in the JSON
+    // string with their string representations. If the original value can not
+    // be found, then `undefined` is used.
+    return str.replace(PLACE_HOLDER_REGEX, function (match, type, index) {
+        if (type === 'REGEXP') {
+            return regexps[index].toString();
+        }
+
+        var fn           = functions[index],
+            serializedFn = fn.toString();
+
+        if (IS_NATIVE_CODE_REGEX.test(serializedFn)) {
+            throw new TypeError('Serializing native function: ' + fn.name);
+        }
+
+        return serializedFn;
+    });
+}