Skip to content

Instantly share code, notes, and snippets.

@dyroffk

dyroffk/forms2.js

Created Sep 29, 2017
Embed
What would you like to do?
Marketo forms2.js
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
function EventEmitter() {
this._events = this._events || {};
this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;
// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function(n) {
if (!isNumber(n) || n < 0 || isNaN(n))
throw TypeError('n must be a positive number');
this._maxListeners = n;
return this;
};
EventEmitter.prototype.emit = function(type) {
var er, handler, len, args, i, listeners;
if (!this._events)
this._events = {};
// If there is no 'error' event listener then throw.
if (type === 'error') {
if (!this._events.error ||
(isObject(this._events.error) && !this._events.error.length)) {
er = arguments[1];
if (er instanceof Error) {
throw er; // Unhandled 'error' event
}
throw TypeError('Uncaught, unspecified "error" event.');
}
}
handler = this._events[type];
if (isUndefined(handler))
return false;
if (isFunction(handler)) {
switch (arguments.length) {
// fast cases
case 1:
handler.call(this);
break;
case 2:
handler.call(this, arguments[1]);
break;
case 3:
handler.call(this, arguments[1], arguments[2]);
break;
// slower
default:
len = arguments.length;
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];
handler.apply(this, args);
}
} else if (isObject(handler)) {
len = arguments.length;
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];
listeners = handler.slice();
len = listeners.length;
for (i = 0; i < len; i++)
listeners[i].apply(this, args);
}
return true;
};
EventEmitter.prototype.addListener = function(type, listener) {
var m;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events)
this._events = {};
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (this._events.newListener)
this.emit('newListener', type,
isFunction(listener.listener) ?
listener.listener : listener);
if (!this._events[type])
// Optimize the case of one listener. Don't need the extra array object.
this._events[type] = listener;
else if (isObject(this._events[type]))
// If we've already got an array, just append.
this._events[type].push(listener);
else
// Adding the second element, need to change to array.
this._events[type] = [this._events[type], listener];
// Check for listener leak
if (isObject(this._events[type]) && !this._events[type].warned) {
var m;
if (!isUndefined(this._maxListeners)) {
m = this._maxListeners;
} else {
m = EventEmitter.defaultMaxListeners;
}
if (m && m > 0 && this._events[type].length > m) {
this._events[type].warned = true;
console.error('(node) warning: possible EventEmitter memory ' +
'leak detected. %d listeners added. ' +
'Use emitter.setMaxListeners() to increase limit.',
this._events[type].length);
if (typeof console.trace === 'function') {
// not supported in IE 10
console.trace();
}
}
}
return this;
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.once = function(type, listener) {
if (!isFunction(listener))
throw TypeError('listener must be a function');
var fired = false;
function g() {
this.removeListener(type, g);
if (!fired) {
fired = true;
listener.apply(this, arguments);
}
}
g.listener = listener;
this.on(type, g);
return this;
};
// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener = function(type, listener) {
var list, position, length, i;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events || !this._events[type])
return this;
list = this._events[type];
length = list.length;
position = -1;
if (list === listener ||
(isFunction(list.listener) && list.listener === listener)) {
delete this._events[type];
if (this._events.removeListener)
this.emit('removeListener', type, listener);
} else if (isObject(list)) {
for (i = length; i-- > 0;) {
if (list[i] === listener ||
(list[i].listener && list[i].listener === listener)) {
position = i;
break;
}
}
if (position < 0)
return this;
if (list.length === 1) {
list.length = 0;
delete this._events[type];
} else {
list.splice(position, 1);
}
if (this._events.removeListener)
this.emit('removeListener', type, listener);
}
return this;
};
EventEmitter.prototype.removeAllListeners = function(type) {
var key, listeners;
if (!this._events)
return this;
// not listening for removeListener, no need to emit
if (!this._events.removeListener) {
if (arguments.length === 0)
this._events = {};
else if (this._events[type])
delete this._events[type];
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
for (key in this._events) {
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = {};
return this;
}
listeners = this._events[type];
if (isFunction(listeners)) {
this.removeListener(type, listeners);
} else {
// LIFO order
while (listeners.length)
this.removeListener(type, listeners[listeners.length - 1]);
}
delete this._events[type];
return this;
};
EventEmitter.prototype.listeners = function(type) {
var ret;
if (!this._events || !this._events[type])
ret = [];
else if (isFunction(this._events[type]))
ret = [this._events[type]];
else
ret = this._events[type].slice();
return ret;
};
EventEmitter.listenerCount = function(emitter, type) {
var ret;
if (!emitter._events || !emitter._events[type])
ret = 0;
else if (isFunction(emitter._events[type]))
ret = 1;
else
ret = emitter._events[type].length;
return ret;
};
function isFunction(arg) {
return typeof arg === 'function';
}
function isNumber(arg) {
return typeof arg === 'number';
}
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
function isUndefined(arg) {
return arg === void 0;
}
},{}],2:[function(require,module,exports){
(function (global){
/*! http://mths.be/punycode v1.2.4 by @mathias */
;(function(root) {
/** Detect free variables */
var freeExports = typeof exports == 'object' && exports;
var freeModule = typeof module == 'object' && module &&
module.exports == freeExports && module;
var freeGlobal = typeof global == 'object' && global;
if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
root = freeGlobal;
}
/**
* The `punycode` object.
* @name punycode
* @type Object
*/
var punycode,
/** Highest positive signed 32-bit float value */
maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
/** Bootstring parameters */
base = 36,
tMin = 1,
tMax = 26,
skew = 38,
damp = 700,
initialBias = 72,
initialN = 128, // 0x80
delimiter = '-', // '\x2D'
/** Regular expressions */
regexPunycode = /^xn--/,
regexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars
regexSeparators = /\x2E|\u3002|\uFF0E|\uFF61/g, // RFC 3490 separators
/** Error messages */
errors = {
'overflow': 'Overflow: input needs wider integers to process',
'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
'invalid-input': 'Invalid input'
},
/** Convenience shortcuts */
baseMinusTMin = base - tMin,
floor = Math.floor,
stringFromCharCode = String.fromCharCode,
/** Temporary variable */
key;
/*--------------------------------------------------------------------------*/
/**
* A generic error utility function.
* @private
* @param {String} type The error type.
* @returns {Error} Throws a `RangeError` with the applicable error message.
*/
function error(type) {
throw RangeError(errors[type]);
}
/**
* A generic `Array#map` utility function.
* @private
* @param {Array} array The array to iterate over.
* @param {Function} callback The function that gets called for every array
* item.
* @returns {Array} A new array of values returned by the callback function.
*/
function map(array, fn) {
var length = array.length;
while (length--) {
array[length] = fn(array[length]);
}
return array;
}
/**
* A simple `Array#map`-like wrapper to work with domain name strings.
* @private
* @param {String} domain The domain name.
* @param {Function} callback The function that gets called for every
* character.
* @returns {Array} A new string of characters returned by the callback
* function.
*/
function mapDomain(string, fn) {
return map(string.split(regexSeparators), fn).join('.');
}
/**
* Creates an array containing the numeric code points of each Unicode
* character in the string. While JavaScript uses UCS-2 internally,
* this function will convert a pair of surrogate halves (each of which
* UCS-2 exposes as separate characters) into a single code point,
* matching UTF-16.
* @see `punycode.ucs2.encode`
* @see <http://mathiasbynens.be/notes/javascript-encoding>
* @memberOf punycode.ucs2
* @name decode
* @param {String} string The Unicode input string (UCS-2).
* @returns {Array} The new array of code points.
*/
function ucs2decode(string) {
var output = [],
counter = 0,
length = string.length,
value,
extra;
while (counter < length) {
value = string.charCodeAt(counter++);
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
// high surrogate, and there is a next character
extra = string.charCodeAt(counter++);
if ((extra & 0xFC00) == 0xDC00) { // low surrogate
output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
} else {
// unmatched surrogate; only append this code unit, in case the next
// code unit is the high surrogate of a surrogate pair
output.push(value);
counter--;
}
} else {
output.push(value);
}
}
return output;
}
/**
* Creates a string based on an array of numeric code points.
* @see `punycode.ucs2.decode`
* @memberOf punycode.ucs2
* @name encode
* @param {Array} codePoints The array of numeric code points.
* @returns {String} The new Unicode string (UCS-2).
*/
function ucs2encode(array) {
return map(array, function(value) {
var output = '';
if (value > 0xFFFF) {
value -= 0x10000;
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
value = 0xDC00 | value & 0x3FF;
}
output += stringFromCharCode(value);
return output;
}).join('');
}
/**
* Converts a basic code point into a digit/integer.
* @see `digitToBasic()`
* @private
* @param {Number} codePoint The basic numeric code point value.
* @returns {Number} The numeric value of a basic code point (for use in
* representing integers) in the range `0` to `base - 1`, or `base` if
* the code point does not represent a value.
*/
function basicToDigit(codePoint) {
if (codePoint - 48 < 10) {
return codePoint - 22;
}
if (codePoint - 65 < 26) {
return codePoint - 65;
}
if (codePoint - 97 < 26) {
return codePoint - 97;
}
return base;
}
/**
* Converts a digit/integer into a basic code point.
* @see `basicToDigit()`
* @private
* @param {Number} digit The numeric value of a basic code point.
* @returns {Number} The basic code point whose value (when used for
* representing integers) is `digit`, which needs to be in the range
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
* used; else, the lowercase form is used. The behavior is undefined
* if `flag` is non-zero and `digit` has no uppercase form.
*/
function digitToBasic(digit, flag) {
// 0..25 map to ASCII a..z or A..Z
// 26..35 map to ASCII 0..9
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
}
/**
* Bias adaptation function as per section 3.4 of RFC 3492.
* http://tools.ietf.org/html/rfc3492#section-3.4
* @private
*/
function adapt(delta, numPoints, firstTime) {
var k = 0;
delta = firstTime ? floor(delta / damp) : delta >> 1;
delta += floor(delta / numPoints);
for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
delta = floor(delta / baseMinusTMin);
}
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
}
/**
* Converts a Punycode string of ASCII-only symbols to a string of Unicode
* symbols.
* @memberOf punycode
* @param {String} input The Punycode string of ASCII-only symbols.
* @returns {String} The resulting string of Unicode symbols.
*/
function decode(input) {
// Don't use UCS-2
var output = [],
inputLength = input.length,
out,
i = 0,
n = initialN,
bias = initialBias,
basic,
j,
index,
oldi,
w,
k,
digit,
t,
/** Cached calculation results */
baseMinusT;
// Handle the basic code points: let `basic` be the number of input code
// points before the last delimiter, or `0` if there is none, then copy
// the first basic code points to the output.
basic = input.lastIndexOf(delimiter);
if (basic < 0) {
basic = 0;
}
for (j = 0; j < basic; ++j) {
// if it's not a basic code point
if (input.charCodeAt(j) >= 0x80) {
error('not-basic');
}
output.push(input.charCodeAt(j));
}
// Main decoding loop: start just after the last delimiter if any basic code
// points were copied; start at the beginning otherwise.
for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
// `index` is the index of the next character to be consumed.
// Decode a generalized variable-length integer into `delta`,
// which gets added to `i`. The overflow checking is easier
// if we increase `i` as we go, then subtract off its starting
// value at the end to obtain `delta`.
for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
if (index >= inputLength) {
error('invalid-input');
}
digit = basicToDigit(input.charCodeAt(index++));
if (digit >= base || digit > floor((maxInt - i) / w)) {
error('overflow');
}
i += digit * w;
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (digit < t) {
break;
}
baseMinusT = base - t;
if (w > floor(maxInt / baseMinusT)) {
error('overflow');
}
w *= baseMinusT;
}
out = output.length + 1;
bias = adapt(i - oldi, out, oldi == 0);
// `i` was supposed to wrap around from `out` to `0`,
// incrementing `n` each time, so we'll fix that now:
if (floor(i / out) > maxInt - n) {
error('overflow');
}
n += floor(i / out);
i %= out;
// Insert `n` at position `i` of the output
output.splice(i++, 0, n);
}
return ucs2encode(output);
}
/**
* Converts a string of Unicode symbols to a Punycode string of ASCII-only
* symbols.
* @memberOf punycode
* @param {String} input The string of Unicode symbols.
* @returns {String} The resulting Punycode string of ASCII-only symbols.
*/
function encode(input) {
var n,
delta,
handledCPCount,
basicLength,
bias,
j,
m,
q,
k,
t,
currentValue,
output = [],
/** `inputLength` will hold the number of code points in `input`. */
inputLength,
/** Cached calculation results */
handledCPCountPlusOne,
baseMinusT,
qMinusT;
// Convert the input in UCS-2 to Unicode
input = ucs2decode(input);
// Cache the length
inputLength = input.length;
// Initialize the state
n = initialN;
delta = 0;
bias = initialBias;
// Handle the basic code points
for (j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue < 0x80) {
output.push(stringFromCharCode(currentValue));
}
}
handledCPCount = basicLength = output.length;
// `handledCPCount` is the number of code points that have been handled;
// `basicLength` is the number of basic code points.
// Finish the basic string - if it is not empty - with a delimiter
if (basicLength) {
output.push(delimiter);
}
// Main encoding loop:
while (handledCPCount < inputLength) {
// All non-basic code points < n have been handled already. Find the next
// larger one:
for (m = maxInt, j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue >= n && currentValue < m) {
m = currentValue;
}
}
// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
// but guard against overflow
handledCPCountPlusOne = handledCPCount + 1;
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
error('overflow');
}
delta += (m - n) * handledCPCountPlusOne;
n = m;
for (j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue < n && ++delta > maxInt) {
error('overflow');
}
if (currentValue == n) {
// Represent delta as a generalized variable-length integer
for (q = delta, k = base; /* no condition */; k += base) {
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (q < t) {
break;
}
qMinusT = q - t;
baseMinusT = base - t;
output.push(
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
);
q = floor(qMinusT / baseMinusT);
}
output.push(stringFromCharCode(digitToBasic(q, 0)));
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
delta = 0;
++handledCPCount;
}
}
++delta;
++n;
}
return output.join('');
}
/**
* Converts a Punycode string representing a domain name to Unicode. Only the
* Punycoded parts of the domain name will be converted, i.e. it doesn't
* matter if you call it on a string that has already been converted to
* Unicode.
* @memberOf punycode
* @param {String} domain The Punycode domain name to convert to Unicode.
* @returns {String} The Unicode representation of the given Punycode
* string.
*/
function toUnicode(domain) {
return mapDomain(domain, function(string) {
return regexPunycode.test(string)
? decode(string.slice(4).toLowerCase())
: string;
});
}
/**
* Converts a Unicode string representing a domain name to Punycode. Only the
* non-ASCII parts of the domain name will be converted, i.e. it doesn't
* matter if you call it with a domain that's already in ASCII.
* @memberOf punycode
* @param {String} domain The domain name to convert, as a Unicode string.
* @returns {String} The Punycode representation of the given domain name.
*/
function toASCII(domain) {
return mapDomain(domain, function(string) {
return regexNonASCII.test(string)
? 'xn--' + encode(string)
: string;
});
}
/*--------------------------------------------------------------------------*/
/** Define the public API */
punycode = {
/**
* A string representing the current Punycode.js version number.
* @memberOf punycode
* @type String
*/
'version': '1.2.4',
/**
* An object of methods to convert from JavaScript's internal character
* representation (UCS-2) to Unicode code points, and back.
* @see <http://mathiasbynens.be/notes/javascript-encoding>
* @memberOf punycode
* @type Object
*/
'ucs2': {
'decode': ucs2decode,
'encode': ucs2encode
},
'decode': decode,
'encode': encode,
'toASCII': toASCII,
'toUnicode': toUnicode
};
/** Expose `punycode` */
// Some AMD build optimizers, like r.js, check for specific condition patterns
// like the following:
if (
typeof define == 'function' &&
typeof define.amd == 'object' &&
define.amd
) {
define('punycode', function() {
return punycode;
});
} else if (freeExports && !freeExports.nodeType) {
if (freeModule) { // in Node.js or RingoJS v0.8.0+
freeModule.exports = punycode;
} else { // in Narwhal or RingoJS v0.7.0-
for (key in punycode) {
punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
}
}
} else { // in Rhino or a web browser
root.punycode = punycode;
}
}(this));
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],3:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
'use strict';
// If obj.hasOwnProperty has been overridden, then calling
// obj.hasOwnProperty(prop) will break.
// See: https://github.com/joyent/node/issues/1707
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
module.exports = function(qs, sep, eq, options) {
sep = sep || '&';
eq = eq || '=';
var obj = {};
if (typeof qs !== 'string' || qs.length === 0) {
return obj;
}
var regexp = /\+/g;
qs = qs.split(sep);
var maxKeys = 1000;
if (options && typeof options.maxKeys === 'number') {
maxKeys = options.maxKeys;
}
var len = qs.length;
// maxKeys <= 0 means that we should not limit keys count
if (maxKeys > 0 && len > maxKeys) {
len = maxKeys;
}
for (var i = 0; i < len; ++i) {
var x = qs[i].replace(regexp, '%20'),
idx = x.indexOf(eq),
kstr, vstr, k, v;
if (idx >= 0) {
kstr = x.substr(0, idx);
vstr = x.substr(idx + 1);
} else {
kstr = x;
vstr = '';
}
k = decodeURIComponent(kstr);
v = decodeURIComponent(vstr);
if (!hasOwnProperty(obj, k)) {
obj[k] = v;
} else if (isArray(obj[k])) {
obj[k].push(v);
} else {
obj[k] = [obj[k], v];
}
}
return obj;
};
var isArray = Array.isArray || function (xs) {
return Object.prototype.toString.call(xs) === '[object Array]';
};
},{}],4:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
'use strict';
var stringifyPrimitive = function(v) {
switch (typeof v) {
case 'string':
return v;
case 'boolean':
return v ? 'true' : 'false';
case 'number':
return isFinite(v) ? v : '';
default:
return '';
}
};
module.exports = function(obj, sep, eq, name) {
sep = sep || '&';
eq = eq || '=';
if (obj === null) {
obj = undefined;
}
if (typeof obj === 'object') {
return map(objectKeys(obj), function(k) {
var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
if (isArray(obj[k])) {
return map(obj[k], function(v) {
return ks + encodeURIComponent(stringifyPrimitive(v));
}).join(sep);
} else {
return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
}
}).join(sep);
}
if (!name) return '';
return encodeURIComponent(stringifyPrimitive(name)) + eq +
encodeURIComponent(stringifyPrimitive(obj));
};
var isArray = Array.isArray || function (xs) {
return Object.prototype.toString.call(xs) === '[object Array]';
};
function map (xs, f) {
if (xs.map) return xs.map(f);
var res = [];
for (var i = 0; i < xs.length; i++) {
res.push(f(xs[i], i));
}
return res;
}
var objectKeys = Object.keys || function (obj) {
var res = [];
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
}
return res;
};
},{}],5:[function(require,module,exports){
'use strict';
exports.decode = exports.parse = require('./decode');
exports.encode = exports.stringify = require('./encode');
},{"./decode":3,"./encode":4}],6:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var punycode = require('punycode');
exports.parse = urlParse;
exports.resolve = urlResolve;
exports.resolveObject = urlResolveObject;
exports.format = urlFormat;
exports.Url = Url;
function Url() {
this.protocol = null;
this.slashes = null;
this.auth = null;
this.host = null;
this.port = null;
this.hostname = null;
this.hash = null;
this.search = null;
this.query = null;
this.pathname = null;
this.path = null;
this.href = null;
}
// Reference: RFC 3986, RFC 1808, RFC 2396
// define these here so at least they only have to be
// compiled once on the first module load.
var protocolPattern = /^([a-z0-9.+-]+:)/i,
portPattern = /:[0-9]*$/,
// RFC 2396: characters reserved for delimiting URLs.
// We actually just auto-escape these.
delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
// RFC 2396: characters not allowed for various reasons.
unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
// Allowed by RFCs, but cause of XSS attacks. Always escape these.
autoEscape = ['\''].concat(unwise),
// Characters that are never ever allowed in a hostname.
// Note that any invalid chars are also handled, but these
// are the ones that are *expected* to be seen, so we fast-path
// them.
nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
hostEndingChars = ['/', '?', '#'],
hostnameMaxLen = 255,
hostnamePartPattern = /^[a-z0-9A-Z_-]{0,63}$/,
hostnamePartStart = /^([a-z0-9A-Z_-]{0,63})(.*)$/,
// protocols that can allow "unsafe" and "unwise" chars.
unsafeProtocol = {
'javascript': true,
'javascript:': true
},
// protocols that never have a hostname.
hostlessProtocol = {
'javascript': true,
'javascript:': true
},
// protocols that always contain a // bit.
slashedProtocol = {
'http': true,
'https': true,
'ftp': true,
'gopher': true,
'file': true,
'http:': true,
'https:': true,
'ftp:': true,
'gopher:': true,
'file:': true
},
querystring = require('querystring');
function urlParse(url, parseQueryString, slashesDenoteHost) {
if (url && isObject(url) && url instanceof Url) return url;
var u = new Url;
u.parse(url, parseQueryString, slashesDenoteHost);
return u;
}
Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
if (!isString(url)) {
throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
}
var rest = url;
// trim before proceeding.
// This is to support parse stuff like " http://foo.com \n"
rest = rest.trim();
var proto = protocolPattern.exec(rest);
if (proto) {
proto = proto[0];
var lowerProto = proto.toLowerCase();
this.protocol = lowerProto;
rest = rest.substr(proto.length);
}
// figure out if it's got a host
// user@server is *always* interpreted as a hostname, and url
// resolution will treat //foo/bar as host=foo,path=bar because that's
// how the browser resolves relative URLs.
if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
var slashes = rest.substr(0, 2) === '//';
if (slashes && !(proto && hostlessProtocol[proto])) {
rest = rest.substr(2);
this.slashes = true;
}
}
if (!hostlessProtocol[proto] &&
(slashes || (proto && !slashedProtocol[proto]))) {
// there's a hostname.
// the first instance of /, ?, ;, or # ends the host.
//
// If there is an @ in the hostname, then non-host chars *are* allowed
// to the left of the last @ sign, unless some host-ending character
// comes *before* the @-sign.
// URLs are obnoxious.
//
// ex:
// http://a@b@c/ => user:a@b host:c
// http://a@b?@c => user:a host:c path:/?@c
// v0.12 TODO(isaacs): This is not quite how Chrome does things.
// Review our test case against browsers more comprehensively.
// find the first instance of any hostEndingChars
var hostEnd = -1;
for (var i = 0; i < hostEndingChars.length; i++) {
var hec = rest.indexOf(hostEndingChars[i]);
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
hostEnd = hec;
}
// at this point, either we have an explicit point where the
// auth portion cannot go past, or the last @ char is the decider.
var auth, atSign;
if (hostEnd === -1) {
// atSign can be anywhere.
atSign = rest.lastIndexOf('@');
} else {
// atSign must be in auth portion.
// http://a@b/c@d => host:b auth:a path:/c@d
atSign = rest.lastIndexOf('@', hostEnd);
}
// Now we have a portion which is definitely the auth.
// Pull that off.
if (atSign !== -1) {
auth = rest.slice(0, atSign);
rest = rest.slice(atSign + 1);
this.auth = decodeURIComponent(auth);
}
// the host is the remaining to the left of the first non-host char
hostEnd = -1;
for (var i = 0; i < nonHostChars.length; i++) {
var hec = rest.indexOf(nonHostChars[i]);
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
hostEnd = hec;
}
// if we still have not hit it, then the entire thing is a host.
if (hostEnd === -1)
hostEnd = rest.length;
this.host = rest.slice(0, hostEnd);
rest = rest.slice(hostEnd);
// pull out port.
this.parseHost();
// we've indicated that there is a hostname,
// so even if it's empty, it has to be present.
this.hostname = this.hostname || '';
// if hostname begins with [ and ends with ]
// assume that it's an IPv6 address.
var ipv6Hostname = this.hostname[0] === '[' &&
this.hostname[this.hostname.length - 1] === ']';
// validate a little.
if (!ipv6Hostname) {
var hostparts = this.hostname.split(/\./);
for (var i = 0, l = hostparts.length; i < l; i++) {
var part = hostparts[i];
if (!part) continue;
if (!part.match(hostnamePartPattern)) {
var newpart = '';
for (var j = 0, k = part.length; j < k; j++) {
if (part.charCodeAt(j) > 127) {
// we replace non-ASCII char with a temporary placeholder
// we need this to make sure size of hostname is not
// broken by replacing non-ASCII by nothing
newpart += 'x';
} else {
newpart += part[j];
}
}
// we test again with ASCII char only
if (!newpart.match(hostnamePartPattern)) {
var validParts = hostparts.slice(0, i);
var notHost = hostparts.slice(i + 1);
var bit = part.match(hostnamePartStart);
if (bit) {
validParts.push(bit[1]);
notHost.unshift(bit[2]);
}
if (notHost.length) {
rest = '/' + notHost.join('.') + rest;
}
this.hostname = validParts.join('.');
break;
}
}
}
}
if (this.hostname.length > hostnameMaxLen) {
this.hostname = '';
} else {
// hostnames are always lower case.
this.hostname = this.hostname.toLowerCase();
}
if (!ipv6Hostname) {
// IDNA Support: Returns a puny coded representation of "domain".
// It only converts the part of the domain name that
// has non ASCII characters. I.e. it dosent matter if
// you call it with a domain that already is in ASCII.
var domainArray = this.hostname.split('.');
var newOut = [];
for (var i = 0; i < domainArray.length; ++i) {
var s = domainArray[i];
newOut.push(s.match(/[^A-Za-z0-9_-]/) ?
'xn--' + punycode.encode(s) : s);
}
this.hostname = newOut.join('.');
}
var p = this.port ? ':' + this.port : '';
var h = this.hostname || '';
this.host = h + p;
this.href += this.host;
// strip [ and ] from the hostname
// the host field still retains them, though
if (ipv6Hostname) {
this.hostname = this.hostname.substr(1, this.hostname.length - 2);
if (rest[0] !== '/') {
rest = '/' + rest;
}
}
}
// now rest is set to the post-host stuff.
// chop off any delim chars.
if (!unsafeProtocol[lowerProto]) {
// First, make 100% sure that any "autoEscape" chars get
// escaped, even if encodeURIComponent doesn't think they
// need to be.
for (var i = 0, l = autoEscape.length; i < l; i++) {
var ae = autoEscape[i];
var esc = encodeURIComponent(ae);
if (esc === ae) {
esc = escape(ae);
}
rest = rest.split(ae).join(esc);
}
}
// chop off from the tail first.
var hash = rest.indexOf('#');
if (hash !== -1) {
// got a fragment string.
this.hash = rest.substr(hash);
rest = rest.slice(0, hash);
}
var qm = rest.indexOf('?');
if (qm !== -1) {
this.search = rest.substr(qm);
this.query = rest.substr(qm + 1);
if (parseQueryString) {
this.query = querystring.parse(this.query);
}
rest = rest.slice(0, qm);
} else if (parseQueryString) {
// no query string, but parseQueryString still requested
this.search = '';
this.query = {};
}
if (rest) this.pathname = rest;
if (slashedProtocol[lowerProto] &&
this.hostname && !this.pathname) {
this.pathname = '/';
}
//to support http.request
if (this.pathname || this.search) {
var p = this.pathname || '';
var s = this.search || '';
this.path = p + s;
}
// finally, reconstruct the href based on what has been validated.
this.href = this.format();
return this;
};
// format a parsed object into a url string
function urlFormat(obj) {
// ensure it's an object, and not a string url.
// If it's an obj, this is a no-op.
// this way, you can call url_format() on strings
// to clean up potentially wonky urls.
if (isString(obj)) obj = urlParse(obj);
if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
return obj.format();
}
Url.prototype.format = function() {
var auth = this.auth || '';
if (auth) {
auth = encodeURIComponent(auth);
auth = auth.replace(/%3A/i, ':');
auth += '@';
}
var protocol = this.protocol || '',
pathname = this.pathname || '',
hash = this.hash || '',
host = false,
query = '';
if (this.host) {
host = auth + this.host;
} else if (this.hostname) {
host = auth + (this.hostname.indexOf(':') === -1 ?
this.hostname :
'[' + this.hostname + ']');
if (this.port) {
host += ':' + this.port;
}
}
if (this.query &&
isObject(this.query) &&
Object.keys(this.query).length) {
query = querystring.stringify(this.query);
}
var search = this.search || (query && ('?' + query)) || '';
if (protocol && protocol.substr(-1) !== ':') protocol += ':';
// only the slashedProtocols get the //. Not mailto:, xmpp:, etc.
// unless they had them to begin with.
if (this.slashes ||
(!protocol || slashedProtocol[protocol]) && host !== false) {
host = '//' + (host || '');
if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
} else if (!host) {
host = '';
}
if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
if (search && search.charAt(0) !== '?') search = '?' + search;
pathname = pathname.replace(/[?#]/g, function(match) {
return encodeURIComponent(match);
});
search = search.replace('#', '%23');
return protocol + host + pathname + search + hash;
};
function urlResolve(source, relative) {
return urlParse(source, false, true).resolve(relative);
}
Url.prototype.resolve = function(relative) {
return this.resolveObject(urlParse(relative, false, true)).format();
};
function urlResolveObject(source, relative) {
if (!source) return relative;
return urlParse(source, false, true).resolveObject(relative);
}
Url.prototype.resolveObject = function(relative) {
if (isString(relative)) {
var rel = new Url();
rel.parse(relative, false, true);
relative = rel;
}
var result = new Url();
Object.keys(this).forEach(function(k) {
result[k] = this[k];
}, this);
// hash is always overridden, no matter what.
// even href="" will remove it.
result.hash = relative.hash;
// if the relative url is empty, then there's nothing left to do here.
if (relative.href === '') {
result.href = result.format();
return result;
}
// hrefs like //foo/bar always cut to the protocol.
if (relative.slashes && !relative.protocol) {
// take everything except the protocol from relative
Object.keys(relative).forEach(function(k) {
if (k !== 'protocol')
result[k] = relative[k];
});
//urlParse appends trailing / to urls like http://www.example.com
if (slashedProtocol[result.protocol] &&
result.hostname && !result.pathname) {
result.path = result.pathname = '/';
}
result.href = result.format();
return result;
}
if (relative.protocol && relative.protocol !== result.protocol) {
// if it's a known url protocol, then changing
// the protocol does weird things
// first, if it's not file:, then we MUST have a host,
// and if there was a path
// to begin with, then we MUST have a path.
// if it is file:, then the host is dropped,
// because that's known to be hostless.
// anything else is assumed to be absolute.
if (!slashedProtocol[relative.protocol]) {
Object.keys(relative).forEach(function(k) {
result[k] = relative[k];
});
result.href = result.format();
return result;
}
result.protocol = relative.protocol;
if (!relative.host && !hostlessProtocol[relative.protocol]) {
var relPath = (relative.pathname || '').split('/');
while (relPath.length && !(relative.host = relPath.shift()));
if (!relative.host) relative.host = '';
if (!relative.hostname) relative.hostname = '';
if (relPath[0] !== '') relPath.unshift('');
if (relPath.length < 2) relPath.unshift('');
result.pathname = relPath.join('/');
} else {
result.pathname = relative.pathname;
}
result.search = relative.search;
result.query = relative.query;
result.host = relative.host || '';
result.auth = relative.auth;
result.hostname = relative.hostname || relative.host;
result.port = relative.port;
// to support http.request
if (result.pathname || result.search) {
var p = result.pathname || '';
var s = result.search || '';
result.path = p + s;
}
result.slashes = result.slashes || relative.slashes;
result.href = result.format();
return result;
}
var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
isRelAbs = (
relative.host ||
relative.pathname && relative.pathname.charAt(0) === '/'
),
mustEndAbs = (isRelAbs || isSourceAbs ||
(result.host && relative.pathname)),
removeAllDots = mustEndAbs,
srcPath = result.pathname && result.pathname.split('/') || [],
relPath = relative.pathname && relative.pathname.split('/') || [],
psychotic = result.protocol && !slashedProtocol[result.protocol];
// if the url is a non-slashed url, then relative
// links like ../.. should be able
// to crawl up to the hostname, as well. This is strange.
// result.protocol has already been set by now.
// Later on, put the first path part into the host field.
if (psychotic) {
result.hostname = '';
result.port = null;
if (result.host) {
if (srcPath[0] === '') srcPath[0] = result.host;
else srcPath.unshift(result.host);
}
result.host = '';
if (relative.protocol) {
relative.hostname = null;
relative.port = null;
if (relative.host) {
if (relPath[0] === '') relPath[0] = relative.host;
else relPath.unshift(relative.host);
}
relative.host = null;
}
mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
}
if (isRelAbs) {
// it's absolute.
result.host = (relative.host || relative.host === '') ?
relative.host : result.host;
result.hostname = (relative.hostname || relative.hostname === '') ?
relative.hostname : result.hostname;
result.search = relative.search;
result.query = relative.query;
srcPath = relPath;
// fall through to the dot-handling below.
} else if (relPath.length) {
// it's relative
// throw away the existing file, and take the new path instead.
if (!srcPath) srcPath = [];
srcPath.pop();
srcPath = srcPath.concat(relPath);
result.search = relative.search;
result.query = relative.query;
} else if (!isNullOrUndefined(relative.search)) {
// just pull out the search.
// like href='?foo'.
// Put this after the other two cases because it simplifies the booleans
if (psychotic) {
result.hostname = result.host = srcPath.shift();
//occationaly the auth can get stuck only in host
//this especialy happens in cases like
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
var authInHost = result.host && result.host.indexOf('@') > 0 ?
result.host.split('@') : false;
if (authInHost) {
result.auth = authInHost.shift();
result.host = result.hostname = authInHost.shift();
}
}
result.search = relative.search;
result.query = relative.query;
//to support http.request
if (!isNull(result.pathname) || !isNull(result.search)) {
result.path = (result.pathname ? result.pathname : '') +
(result.search ? result.search : '');
}
result.href = result.format();
return result;
}
if (!srcPath.length) {
// no path at all. easy.
// we've already handled the other stuff above.
result.pathname = null;
//to support http.request
if (result.search) {
result.path = '/' + result.search;
} else {
result.path = null;
}
result.href = result.format();
return result;
}
// if a url ENDs in . or .., then it must get a trailing slash.
// however, if it ends in anything else non-slashy,
// then it must NOT get a trailing slash.
var last = srcPath.slice(-1)[0];
var hasTrailingSlash = (
(result.host || relative.host) && (last === '.' || last === '..') ||
last === '');
// strip single dots, resolve double dots to parent dir
// if the path tries to go above the root, `up` ends up > 0
var up = 0;
for (var i = srcPath.length; i >= 0; i--) {
last = srcPath[i];
if (last == '.') {
srcPath.splice(i, 1);
} else if (last === '..') {
srcPath.splice(i, 1);
up++;
} else if (up) {
srcPath.splice(i, 1);
up--;
}
}
// if the path is allowed to go above the root, restore leading ..s
if (!mustEndAbs && !removeAllDots) {
for (; up--; up) {
srcPath.unshift('..');
}
}
if (mustEndAbs && srcPath[0] !== '' &&
(!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
srcPath.unshift('');
}
if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
srcPath.push('');
}
var isAbsolute = srcPath[0] === '' ||
(srcPath[0] && srcPath[0].charAt(0) === '/');
// put the host back
if (psychotic) {
result.hostname = result.host = isAbsolute ? '' :
srcPath.length ? srcPath.shift() : '';
//occationaly the auth can get stuck only in host
//this especialy happens in cases like
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
var authInHost = result.host && result.host.indexOf('@') > 0 ?
result.host.split('@') : false;
if (authInHost) {
result.auth = authInHost.shift();
result.host = result.hostname = authInHost.shift();
}
}
mustEndAbs = mustEndAbs || (result.host && srcPath.length);
if (mustEndAbs && !isAbsolute) {
srcPath.unshift('');
}
if (!srcPath.length) {
result.pathname = null;
result.path = null;
} else {
result.pathname = srcPath.join('/');
}
//to support request.http
if (!isNull(result.pathname) || !isNull(result.search)) {
result.path = (result.pathname ? result.pathname : '') +
(result.search ? result.search : '');
}
result.auth = relative.auth || result.auth;
result.slashes = result.slashes || relative.slashes;
result.href = result.format();
return result;
};
Url.prototype.parseHost = function() {
var host = this.host;
var port = portPattern.exec(host);
if (port) {
port = port[0];
if (port !== ':') {
this.port = port.substr(1);
}
host = host.substr(0, host.length - port.length);
}
if (host) this.hostname = host;
};
function isString(arg) {
return typeof arg === "string";
}
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
function isNull(arg) {
return arg === null;
}
function isNullOrUndefined(arg) {
return arg == null;
}
},{"punycode":2,"querystring":5}],7:[function(require,module,exports){
/// Serialize the a name value pair into a cookie string suitable for
/// http headers. An optional options object specified cookie parameters
///
/// serialize('foo', 'bar', { httpOnly: true })
/// => "foo=bar; httpOnly"
///
/// @param {String} name
/// @param {String} val
/// @param {Object} options
/// @return {String}
var serialize = function(name, val, opt){
opt = opt || {};
var enc = opt.encode || encode;
var pairs = [name + '=' + enc(val)];
if (opt.maxAge) pairs.push('Max-Age=' + opt.maxAge);
if (opt.domain) pairs.push('Domain=' + opt.domain);
if (opt.path) pairs.push('Path=' + opt.path);
if (opt.expires) pairs.push('Expires=' + opt.expires.toUTCString());
if (opt.httpOnly) pairs.push('HttpOnly');
if (opt.secure) pairs.push('Secure');
return pairs.join('; ');
};
var regexTrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
var trim = function (str){
if(str.trim){
return str.trim();
}
return str.replace(regexTrim, "");
}
/// Parse the given cookie header string into an object
/// The object has the various cookies as keys(names) => values
/// @param {String} str
/// @return {Object}
var parse = function(str, opt) {
opt = opt || {};
var obj = {}
var pairs = str.split(/[;,] */);
var dec = opt.decode || decode;
var len = pairs.length;
for(var i = 0; i < len ; i++){
var pair = pairs[i];
var eq_idx = pair.indexOf('=')
// skip things that don't look like key=value
if (eq_idx < 0) {
continue;
}
var key = trim(pair.substr(0, eq_idx));
var val = trim(pair.substr(++eq_idx, pair.length));
// quoted values
if ('"' == val[0]) {
val = val.slice(1, -1);
}
// only assign once
if (undefined == obj[key]) {
try {
obj[key] = dec(val);
} catch (e) {
obj[key] = val;
}
}
};
return obj;
};
var encode = encodeURIComponent;
var decode = decodeURIComponent;
module.exports.serialize = serialize;
module.exports.parse = parse;
},{}],8:[function(require,module,exports){
module.exports = require("./jquery.build.js");
},{"./jquery.build.js":9}],9:[function(require,module,exports){
/**
* The JQuery.node plugin. A DOM builder in the spirit of the Scriptaculous
* Builder.Node.
*
* Copyright (c) 2011 Ian Taylor
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
(function (){
var ctor = function ($, document){
/** Capability detection **/
// IE Pre 9 has a weird bug with buttons and input tags that
// causes it to throw exceptions when trying to set type
// After the element has been created.
var hasNormalInputButtonCreate = true;
try{
var btn = document.createElement("button");
btn.type = "button";
}
catch (e){
hasNormalInputButtonCreate = false;
}
//IE < 9 can't create stylesheets like normal elements, it has to use
//a funky cssText property on its proprietary styleSheet object.
var tempStyle = document.createElement("style");
tempStyle.type = "text/css";
var funkyStylesheetCreate = tempStyle.styleSheet && ('cssText' in tempStyle.styleSheet);
//Many versions of IE will eat spaces off the front and back of text nodes
var spaceTestElem = document.createElement("div");
spaceTestElem.innerHTML = " s ";
var spaceTestValue = spaceTestElem.childNodes[0].nodeValue;
var requiresLeadingSpace = spaceTestValue.indexOf(" ") != 0;
var requiresTrailingSpace = spaceTestValue.lastIndexOf(" ") != 2;
/** End Capability detection */
/** Support functions */
//Regex Caching
var regexApos = /&apos;/g;
var regexLt = /</g;
var regexGt = />/g;
// These selector expressions were ripped from the Sizzle code.
var elemExpr = /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/;
var idExpr = /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/;
var classExpr = /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/g;
var attrExpr = /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/g;
var attrPart = /[\[\]]/g;
/**
* Creates a shallow clone of an array.
*/
var arrayClone = function (arr){
var a = [];
$.each(arr, function (i, o){a.push(o);});
return a;
};
var addHtmlTextToFrag = function (f, text){
};
var addPlainTextToFrag = function (f, text){
if(requiresLeadingSpace && text.charAt(0) === " "){
f.appendChild(document.createTextNode(" "));
}
f.appendChild(document.createTextNode(text));
if(requiresTrailingSpace && text.charAt(text.length -1) === " "){
f.appendChild(document.createTextNode(" "));
}
};
var addFx = function (f, item){
if(!item){
return;
}
if (item.jquery){
f.appendChild(item.get(0));
}
else if (item.nodeType == 1 || item.nodeType == 3 || item.nodeType == 11){
/* Element, Text, and DocumentFragment nodes get appended */
f.appendChild(item);
}
else if ($.isArray(item)){
var i = 0;
var l = item.length;
for(i = 0; i < l; i++){
addFx(f, item[i]);
}
}
else{
addPlainTextToFrag(f, item.toString());
}
};
/**
* @function Allows you to create a new DocumentFragment node by passing in
* jQuery objects, Dom Nodes, or text strings, either inside of an
* array or as a single item.
*
* See: http://ejohn.org/blog/dom-documentfragments/ for more on why to use
* documentfragments.
*/
var docFrag = function (children){
var f = document.createDocumentFragment();
if (children){
if ($.isArray(children)) {
var i =0;
var l = children.length;
for(i = 0; i < l; i++){
addFx(f, children[i]);
}
}
else {
addFx(f,children);
}
}
return f;
};
/**
* @function This function converts a HTML string to a DocumentFragment.
* It uses Element.innerHTML to do the parsing, so it's as fast as possible.
*
* Basically, if you want HTML to pass through $.build without it being HTMLEncoded,
* you must wrap the text with a call to this function.
*
*
* @example:
* $.build("div", [
* $.build.html("This is a <em>HTML</em> string!"),
* "This is a <em>Plain Text</em> string!
* ]);
* result:
* <div>
* This is a <em>HTML</em> string!
* This is a &lt;em&gt;Plain Text&lt;/em&gt; string!
* </div>
*/
var html = function (text){
var f = document.createDocumentFragment();
if(text){
//Browsers/DOM impls supporting DocumentFragment.innerHTML get a fast track.
if(typeof f.innerHTML != "undefined"){
f.innerHTML = text;
}else{
var tempElem = document.createElement("div");
tempElem.innerHTML = text.replace(regexApos, "'");
if(requiresLeadingSpace && text.indexOf(" ") == 0){
f.appendChild(document.createTextNode(" "));
}
while(tempElem.hasChildNodes()){
//appending to a new parent removes the item from the old parent,
//thus this operation is safe and fast.
f.appendChild(tempElem.firstChild);
}
if(requiresTrailingSpace && text.lastIndexOf(" ") == (text.length -1)){
f.appendChild(document.createTextNode(" "));
}
}
}
return f;
};
/* End support functions */
$.build = function (selector, attributes, children){
if(arguments.length == 2 && attributes!=null &&
(typeof attributes == "string" || $.isArray(attributes) || attributes.nodeType || attributes.jquery)){
children = attributes;
attributes = null;
}
selector = selector || "";
var elemTag;
elemTag = selector.match(elemExpr);
if(elemTag){
elemTag = elemTag[0];
}
var id = null;
if(selector.indexOf("#") != -1){
var id = selector.match(idExpr);
if (id){
id = id[1];
}
else{
id = null;
}
}
var className;
if(selector.indexOf(".") != -1){
className = selector.match(classExpr);
}
var attrs;
if(selector.indexOf("[") != -1){
attrs = selector.match(attrExpr);
}
elemTag = elemTag || "div";
if (attrs){
attributes = attributes || {};
$.each(attrs, function (i, attr){
var parts = attr.replace(attrPart, "").split("=");
if (parts && parts.length ==2){
attributes[parts[0]] = parts[1];
}
});
}
attributes = attributes || {};
var elem;
if(!hasNormalInputButtonCreate && (elemTag === "input" || elemTag ==="button")){
// In IE versions before IE 9, an input or button type can only be set
// once, at creation. If you try to set it
// after the fact, you get exceptions
var type = attributes.type ? "type=\""+attributes.type+"\"" : "";
// Name has to be set at creation time for radio buttons only, but
// doesn't hurt for any other input/buttons.
var name = attributes.name ? "name=\""+attributes.name+"\"" : "";
elem = document.createElement("<"+elemTag+" " +type+" " +name+">");
delete attributes["type"];
delete attributes["name"];
}
else{
elem = document.createElement(elemTag);
}
var jqElem = $(elem);
// Set the attributes using jQuery.
if(attributes){
jqElem.attr(attributes);
}
if(id){
elem.id = id;
}
if(elemTag === "img"){
// IE 8 bug with image elements in IE 8 standards mode.
// IE 8 will automatically add in width and height attributes to 'help'
// you if it has the image already in its cache.
// in doing so, it craps up it's own rendering if there is a max-height
// or max-width style applied.
// we will remove any unrequested height and width attributes here.
if(!attributes.width){
jqElem.removeAttr("width");
}
if(!attributes.height){
jqElem.removeAttr("height");
}
}
if (className){
var cls ="";
$.each(className, function (i, str) { cls+= str.replace(".", "") + " ";});
elem.className = $.trim(elem.className + " " + cls);
}
if(funkyStylesheetCreate && elemTag == "style" && typeof children === "string"){
//IE < 9 has a weird implementation of stylesheets,
//You can't just append a normal text node of styles to a style element,
//You have to first give the stylesheet a type of "text/css", then add the string
//as the cssText property.
if(!jqElem.attr("type")){
jqElem.attr("type", "text/css");
}
elem.styleSheet.cssText = children;
}else if (children){
if(children.nodeType == 11)
// Already a document fragment.
elem.appendChild(children);
else
elem.appendChild(docFrag(children));
}
return jqElem;
};
//expose docFrag and html children of $.build
$.build.docFrag = docFrag;
$.build.html = html;
return $.build;
};
if(typeof module !== "undefined" && module.exports){
module.exports = ctor;
}
if(typeof window !== "undefined" && window.jQuery && window.document) {
ctor(window.jQuery, window.document);
}
}
)();
},{}],10:[function(require,module,exports){
var $ = require("./jquery.js");
var comparators = require("./comparators.js");
var fh = require("./fields/fieldhelpers.js");
//Deals with visiblity rules, dependency management
module.exports = {
getChangeMap:getChangeMap,
fieldChangeChecker:fieldChangeChecker,
applyPicklistAlterations:applyPicklistAlterations
}
function getChangeMap(fields, formDescriptor){
var changeMap ={};
$.each(fields, function(i, field){
if(field.Datatype == "hidden" || field.Datatype == "profiling"){
//Don't evaluate visibility rules on hidden or profiling fields.
return;
}
var vr = field.VisibilityRule;
if(vr){
//Every field in a fieldset is dependent on the fieldset.
if(field.Datatype == "fieldset"){
if(formDescriptor.fieldsetRows.length > 0) {
var childFields = fh.flatten(formDescriptor.fieldsetRows[""+field.Id]);
var deps = changeMap[field.Name];
if(!deps){
deps = [];
}
deps = deps.concat($.map(childFields, function (f){return f.Name;}));
changeMap[field.Name] = deps;
}
}
//New format has more than one rule.
var rules = vr.rules || [vr];
$.each(rules, function (i, rule){
if(typeof rule === "string"){
return;
}
var dependents = changeMap[rule.subjectField];
if(!dependents){
dependents = [];
}
if($.inArray(field.Name, dependents) === -1){
dependents.push(field.Name);
}
changeMap[rule.subjectField] = dependents;
});
}
});
return changeMap;
}
function firstItem (arr, test){
var len = arr.length;
for(var i =0; i < len; i++){
var item = arr[i];
if(test(item)){
return item;
}
}
return undefined;
}
function applyPicklistAlterations (field, rule){
if(rule && (field.PicklistValues || rule.picklistKeys || rule.altLabel)){
//make a deep copy of the field
field = $.extend(true, {}, field);
if (field.PicklistValues){
if (rule.picklistFilterValues){
// The filter is a list of label/value objects, need to compare both fields
// Build map from values to list of labels to avoid nested loop search
var filterKeysToValues = {};
$.each(rule.picklistFilterValues, function (i, val){
if (!filterKeysToValues.hasOwnProperty(val.value)){
filterKeysToValues[val.value] = [];
}
filterKeysToValues[val.value].push(val.label);
});
field.PicklistValues = $.map(field.PicklistValues, function (val){
if (filterKeysToValues.hasOwnProperty(val.value) && $.inArray(val.label, filterKeysToValues[val.value]) != -1){
return val;
}
});
}
else if (rule.picklistKeys){
// Pre-February2014, the picklistKeys property was used to filter
// the values for the picklist, was replaced by picklistFilterValues to avoid problems
// with to values having the same keys (see above)
//Filter the picklist values by the keys
field.PicklistValues = $.map(field.PicklistValues, function (val){
if($.inArray(val.value, rule.picklistKeys) != -1){
return val;
}
});
}
}
//Set the new label
if(rule.altLabel){
field.InputLabel = rule.altLabel;
}
}
return field;
}
function fieldChangeChecker (vr, vals){
if(!vr){
return {show:true};
}
var show = vr.defaultVisibility == "show";
var rules = vr.rules || [vr];
var results = $.map(rules, function (rule){
if(typeof rule === "string"){
return;
}
var val = vals[rule.subjectField];
if(!$.isArray(val)){
val = val ? [val] : []
}
var comparator = comparators[rule.operator];
var ok = comparator(val, rule.values);
if(ok){
return rule;
}
return null;
});
var activeRule = firstItem(results, function (item){
return item !== null;
})
if(show){
//If something is default "show"
//Then it is shown when ALL of the value tests provided fail
return {show:!activeRule, rule:activeRule};
}else{
//If something is default "hide", then it is shown when ANY of the
//tests pass
return {show:!!activeRule, rule:activeRule};
}
}
},{"./comparators.js":12,"./fields/fieldhelpers.js":16,"./jquery.js":31}],11:[function(require,module,exports){
module.exports = {
parseColor:parseColor,
compareColor:compareColor
}
/**
Parses a color string into an array [r,g,b,a];
supports the following formats:
#fff
#ffffff
rgba(255,255,255,0)
rgb(255,255,255)
returns null if the string wasn't a valid color.
*/
function parseColor (color){
var match;
var p = parseInt;
color = (color || '').replace(/\s\s*/g,'');
/* jshint -W084 */
// #000000 format
if (match = /^#([\da-f]{2})([\da-f]{2})([\da-f]{2})/i.exec(color)){
return [p(match[1], 16), p(match[2], 16), p(match[3], 16), 1];
}
// #000 format
else if (match = /^#([\da-f])([\da-f])([\da-f])/i.exec(color)){
return [p(match[1], 16) * 17, p(match[2], 16) * 17, p(match[3], 16) * 17, 1];
}
//rgba(0,0,0,0) format
else if (match = /^rgba\(([\d]+),([\d]+),([\d]+),([\d]+|[\d]*.[\d]+)\)/i.exec(color)){
return [+match[1], +match[2], +match[3], +match[4]];
}
// rgb(0,0,0) format
else if (match = /^rgb\(([\d]+),([\d]+),([\d]+)\)/i.exec(color)){
return [+match[1], +match[2], +match[3], 1];
}
/* jshint +W084 */
return null;
}
/**
Compares two colors strings by value
returns true if they're both valid colors and match, false otherwise.
*/
function compareColor (color1, color2){
var c1 = parseColor(color1);
var c2 = parseColor(color2);
if(!c1 || !c2){
return false;
}
for(var i = 0; i < 4; i++){
if(c1[i] !== c2[i]){
return false;
}
}
return true;
}
},{}],12:[function(require,module,exports){
var intersect = function (x, y, fn){
var ret = [];
for (var i = 0; i < x.length; i++) {
for (var z = 0; z < y.length; z++) {
if (fn(x[i],y[z])) {
ret.push(x[i]);
break;
}
}
}
return ret;
}
var comparators = {
//tests if any elements from array are equal to any elements in array b
equal: function (a, b){
var fn = function(x,y){
return x === y;
};
return intersect(a, b, fn).length > 0;
},
//returns true if all values in array a are not in array b
notEqual: function (a, b){
var fn = function(x,y){
return x === y;
};
return intersect(a, b, fn).length === 0;
},
//returns true if there is no value
empty: function(a,b){
return a.length === 0;
},
//returns true if there is a value
notEmpty: function(a,b){
return a.length > 0;
},
//returns true if there is a value
any: function(a,b){
return a.length > 0;
},
//returns true if any value begins with any supplied value
startsWith: function(a,b){
var fn = function(x,y){
return x.indexOf(y) === 0;
};
return intersect(a, b, fn).length > 0;
},
//returns true if no value begins with any supplied value
notStartsWith: function(a,b){
var fn = function(x,y){
return x.indexOf(y) === 0;
};
return intersect(a, b, fn).length === 0;
},
//returns true if any value begins with any supplied value
endsWith: function(a,b){
var fn = function(x,y){
return x.slice(-y.length) === y;
};
return intersect(a, b, fn).length > 0;
},
//returns true if no value begins with any supplied value
notEndsWith: function(a,b){
var fn = function(x,y){
return x.slice(-y.length) === y;
};
return intersect(a, b, fn).length === 0;
},
//returns true if any value contains any supplied value
contains: function(a,b){
var fn = function(x,y){
return x.match(new RegExp(y, 'g'));
};
return intersect(a, b, fn).length > 0;
},
//returns true if no value contains any supplied value
notContains: function(a,b){
var fn = function(x,y){
return x.match(new RegExp(y, 'g'));
};
return intersect(a, b, fn).length === 0;
},
//returns true if value is greater or equal to supplied value
atLeast: function(a,b){
return a[0] >= b[0];
},
//returns true if value is less than or equal to supplied value
atMost: function(a,b){
return a[0] <= b[0];
},
//returns true if number is greater than supplied value
greaterThan: function(a,b){
return a[0] > b[0];
},
//returns true if number is less than supplied value
lessThan: function(a,b){
return a[0] < b[0];
},
//returns true if number is between two given values
between: function(a,b){
return a[0] > b[0] && a[0] < b[1];
},
//returns true if number is not between two given values
notBetween: function(a,b){
return a[0] < b[0] || a[0] > b[1];
},
//returns true if value is between two supplied dates
inTimeFrame: function(formVals,compVals){
return (new Date(formVals[0])) > (new Date(compVals[0])) && (new Date(formVals[0])) < (new Date(compVals[1]));
},
//returns true if value is not between two supplied dates
notInTimeFrame: function(formVals,compVals){
return (new Date(formVals[0]) < new Date(compVals[0]) || new Date(formVals[0]) > new Date(compVals[1]));
},
//returns true if value is before now
inPast: function(formVals,compVals){
return (new Date(formVals[0])) < (new Date());
},
//returns true if value is now or in the future
notInPast: function(formVals,compVals){
return (new Date(formVals[0])) >= (new Date());
},
//returns true if value is before given date
before: function(formVals,compVals){
return (new Date(formVals[0])) < (new Date(compVals[0]));
},
//returns true if value is after given date
after: function(formVals,compVals){
return (new Date(formVals[0])) > (new Date(compVals[0]));
},
//returns true if value is equal to or before the given date
onOrBefore: function (formVals, compVals){
return (new Date(formVals[0])) <= (new Date(compVals[0]));
},
//returns true if value is equal to or after the given date
onOrAfter: function(formVals,compVals){
return (new Date(formVals[0])) >= (new Date(compVals[0]));
}
};
module.exports = comparators;
},{}],13:[function(require,module,exports){
var cookie = require("cookie");
/*
* Unsets a cookie on all sub domains.
* @param cookieName the name of the cookie to remove
* @param hostname the name of the host to remove cookies from, or location.hostname if unset
* @returns an array of all the domains that were unset.
*/
function removeCookieAllDomains (cookieName, hostname){
hostname = hostname || location.hostname;
var d = new Date();
d.setFullYear(d.getFullYear() -1);
//Unset on current domain.
var removedDomains = [];
document.cookie = cookie.serialize(cookieName, "", {expires:d, path:"/"});
removedDomains.push("");
//Unset on each sub domain...
//So if the current domain is www.foo.bar.baz.com
//We'd unset .www.foo.bar.baz.com, then .foo.bar.baz.com, then .bar.baz.com, then .baz.com;
var hostParts = hostname.split(".");
while(hostParts.length > 1 ){
var domain = "." + hostParts.join(".");
document.cookie = cookie.serialize(cookieName, "", {expires:d, path:"/", domain:domain});
removedDomains.push(domain);
hostParts.shift();
}
return removedDomains;
}
module.exports.removeCookieAllDomains = removeCookieAllDomains;
},{"cookie":7}],14:[function(require,module,exports){
var $ = require("../jquery.js");
var $b = $.build;
var fh = require("./fieldHelpers.js");
var currency = {};
module.exports = currency;
currency.fieldType = "currency";
var currencyPattern = /[0-9]+/g;
var validateCurrency = function (v){
if(!v){
return true;
}
return v.match(currencyPattern);
}
currency.newField = function (field, formData){
var e = fh.renderInput("text", field, formData);
return {
name:field.Name,
elem:fh.formatStandardField(e, field, formData),
val:$.proxy(e.val, e),
required:field.IsRequired,
validator:validateCurrency,
validatorElem:e,
onChange:function (fn){
e.on("change", fn);
}
}
}
},{"../jquery.js":31,"./fieldHelpers.js":15}],15:[function(require,module,exports){
var $ = require("../jquery.js");
var $b = $.build;
var fieldHelpers = {};
fieldHelpers.splitSemis = function (str){
str = "" + str;
return str.split(/\s?;\s?/);
};
fieldHelpers.cap = function (s){
return s.charAt(0).toUpperCase() + s.slice(1);
};
fieldHelpers.first = function (){
for (var i = 0; i < arguments.length; i++){
var v = arguments[i];
if(v !== null && v!== undefined){
return v;
}
}
return null;
};
fieldHelpers.formatStandardField = function(fieldElem, field, formData){
var first = fieldHelpers.first;
var fieldWrap;
var elems = $b.docFrag([
$b(".mktoOffset").css({width:first(field.OffsetWidth, formData.OffsetWidth, 0)}),
fieldWrap = $b(".mktoFieldWrap",[
$b("label.mktoLabel.mktoHasWidth", {"for":field.Name}, [
$b(".mktoAsterix", "*"),
$b.html(field.InputLabel)
]).css({
width: first(field.LabelWidth, formData.LabelWidth, 0)
}),
$b(".mktoGutter.mktoHasWidth").css({width:first(field.GutterWidth,formData.GutterWidth,0)}),
fieldElem.addClass("mktoHasWidth").css({width:first(field.FieldWidth, formData.FieldWidth, 0 )}),
$b(".mktoClear")
]
),
$b(".mktoClear")
]);
if(field.IsRequired){
fieldWrap.addClass("mktoRequiredField");
}
return elems;
}
fieldHelpers.renderInput = function (type, field, formData){
var e = $b("input[type="+type+"].mktoField.mkto"+fieldHelpers.cap(type)+"Field", {
id:field.Name,
name:field.Name,
placeholder:field.PlaceholderText,
maxlength:field.Maxlength || 2000,
title:field.Description
})
return e;
}
fieldHelpers.isSet = function (v){
return v !== null && v !== undefined;
}
fieldHelpers.flatten = function (arr, accum){
accum = accum || [];
$.each(arr, function (i, v){
if($.isArray(v)){
fieldHelpers.flatten(v, accum);
}else{
accum.push(v);
}
});
return accum;
}
fieldHelpers.vals = function (obj){
return $.map(obj, function (val){return val;});
}
fieldHelpers.getFlattenedFields = function (formData){
var fields = [];
fields = fieldHelpers.flatten(formData.rows);
if(formData.fieldsetRows){
fields = fields.concat(fieldHelpers.flatten(fieldHelpers.vals(formData.fieldsetRows)));
}
return fields;
};
/**
* returns an object with a key with value = true for each Datatype in a list of fields
* eg: {textarea:true, range:true, date:true}
* see: getFlatenenedFields() for how to get a list of fields to pass to this.
*/
fieldHelpers.getFieldTypes = function (fields){
var fieldTypes = {};
for(var i = 0; i < fields.length; i++){
fieldTypes[fields[i].Datatype] = true;
}
return fieldTypes;
};
/**
* returns true if any field in fields list has a set property named propertyName
* see: getFlatenenedFields() for how to get a list of fields to pass to this.
*/
fieldHelpers.anyFieldHasProperty = function (fields, propertyName){
for(var i =0; i < fields.length ; i++){
if(fields[i][propertyName]){
return true;
}
}
return false;
};
fieldHelpers.getFieldsByName = function(fields){
var fieldsByName = {};
$.each(fields, function (i, v){
fieldsByName[v.Name] = v;
});
return fieldsByName;
};