yy-form-making
Version:
1,825 lines (1,750 loc) • 433 kB
JavaScript
(function () {
var mobile = (function () {
'use strict';
var noop = function () {
var x = [];
for (var _i = 0; _i < arguments.length; _i++) {
x[_i] = arguments[_i];
}
};
var compose = function (fa, fb) {
return function () {
var x = [];
for (var _i = 0; _i < arguments.length; _i++) {
x[_i] = arguments[_i];
}
return fa(fb.apply(null, arguments));
};
};
var constant = function (value) {
return function () {
return value;
};
};
var identity = function (x) {
return x;
};
var curry = function (f) {
var x = [];
for (var _i = 1; _i < arguments.length; _i++) {
x[_i - 1] = arguments[_i];
}
var args = new Array(arguments.length - 1);
for (var i = 1; i < arguments.length; i++)
args[i - 1] = arguments[i];
return function () {
var x = [];
for (var _i = 0; _i < arguments.length; _i++) {
x[_i] = arguments[_i];
}
var newArgs = new Array(arguments.length);
for (var j = 0; j < newArgs.length; j++)
newArgs[j] = arguments[j];
var all = args.concat(newArgs);
return f.apply(null, all);
};
};
var not = function (f) {
return function () {
var x = [];
for (var _i = 0; _i < arguments.length; _i++) {
x[_i] = arguments[_i];
}
return !f.apply(null, arguments);
};
};
var die = function (msg) {
return function () {
throw new Error(msg);
};
};
var apply = function (f) {
return f();
};
var never = constant(false);
var always = constant(true);
var typeOf = function (x) {
if (x === null)
return 'null';
var t = typeof x;
if (t === 'object' && Array.prototype.isPrototypeOf(x))
return 'array';
if (t === 'object' && String.prototype.isPrototypeOf(x))
return 'string';
return t;
};
var isType = function (type) {
return function (value) {
return typeOf(value) === type;
};
};
var isString = isType('string');
var isObject = isType('object');
var isArray = isType('array');
var isBoolean = isType('boolean');
var isFunction = isType('function');
var isNumber = isType('number');
var hasOwnProperty = Object.prototype.hasOwnProperty;
var shallow = function (old, nu) {
return nu;
};
var deep = function (old, nu) {
var bothObjects = isObject(old) && isObject(nu);
return bothObjects ? deepMerge(old, nu) : nu;
};
var baseMerge = function (merger) {
return function () {
var objects = new Array(arguments.length);
for (var i = 0; i < objects.length; i++)
objects[i] = arguments[i];
if (objects.length === 0)
throw new Error('Can\'t merge zero objects');
var ret = {};
for (var j = 0; j < objects.length; j++) {
var curObject = objects[j];
for (var key in curObject)
if (hasOwnProperty.call(curObject, key)) {
ret[key] = merger(ret[key], curObject[key]);
}
}
return ret;
};
};
var deepMerge = baseMerge(deep);
var merge = baseMerge(shallow);
var never$1 = never;
var always$1 = always;
var none = function () {
return NONE;
};
var NONE = function () {
var eq = function (o) {
return o.isNone();
};
var call$$1 = function (thunk) {
return thunk();
};
var id = function (n) {
return n;
};
var noop$$1 = function () {
};
var nul = function () {
return null;
};
var undef = function () {
return undefined;
};
var me = {
fold: function (n, s) {
return n();
},
is: never$1,
isSome: never$1,
isNone: always$1,
getOr: id,
getOrThunk: call$$1,
getOrDie: function (msg) {
throw new Error(msg || 'error: getOrDie called on none.');
},
getOrNull: nul,
getOrUndefined: undef,
or: id,
orThunk: call$$1,
map: none,
ap: none,
each: noop$$1,
bind: none,
flatten: none,
exists: never$1,
forall: always$1,
filter: none,
equals: eq,
equals_: eq,
toArray: function () {
return [];
},
toString: constant('none()')
};
if (Object.freeze)
Object.freeze(me);
return me;
}();
var some = function (a) {
var constant_a = function () {
return a;
};
var self = function () {
return me;
};
var map = function (f) {
return some(f(a));
};
var bind = function (f) {
return f(a);
};
var me = {
fold: function (n, s) {
return s(a);
},
is: function (v) {
return a === v;
},
isSome: always$1,
isNone: never$1,
getOr: constant_a,
getOrThunk: constant_a,
getOrDie: constant_a,
getOrNull: constant_a,
getOrUndefined: constant_a,
or: self,
orThunk: self,
map: map,
ap: function (optfab) {
return optfab.fold(none, function (fab) {
return some(fab(a));
});
},
each: function (f) {
f(a);
},
bind: bind,
flatten: constant_a,
exists: bind,
forall: bind,
filter: function (f) {
return f(a) ? me : NONE;
},
equals: function (o) {
return o.is(a);
},
equals_: function (o, elementEq) {
return o.fold(never$1, function (b) {
return elementEq(a, b);
});
},
toArray: function () {
return [a];
},
toString: function () {
return 'some(' + a + ')';
}
};
return me;
};
var from = function (value) {
return value === null || value === undefined ? NONE : some(value);
};
var Option = {
some: some,
none: none,
from: from
};
var keys = Object.keys;
var each = function (obj, f) {
var props = keys(obj);
for (var k = 0, len = props.length; k < len; k++) {
var i = props[k];
var x = obj[i];
f(x, i, obj);
}
};
var map = function (obj, f) {
return tupleMap(obj, function (x, i, obj) {
return {
k: i,
v: f(x, i, obj)
};
});
};
var tupleMap = function (obj, f) {
var r = {};
each(obj, function (x, i) {
var tuple = f(x, i, obj);
r[tuple.k] = tuple.v;
});
return r;
};
var mapToArray = function (obj, f) {
var r = [];
each(obj, function (value, name) {
r.push(f(value, name));
});
return r;
};
var touchstart = constant('touchstart');
var touchmove = constant('touchmove');
var touchend = constant('touchend');
var mousedown = constant('mousedown');
var mousemove = constant('mousemove');
var mouseup = constant('mouseup');
var mouseover = constant('mouseover');
var keydown = constant('keydown');
var input = constant('input');
var change = constant('change');
var click = constant('click');
var transitionend = constant('transitionend');
var selectstart = constant('selectstart');
var cached = function (f) {
var called = false;
var r;
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (!called) {
called = true;
r = f.apply(null, args);
}
return r;
};
};
var firstMatch = function (regexes, s) {
for (var i = 0; i < regexes.length; i++) {
var x = regexes[i];
if (x.test(s))
return x;
}
return undefined;
};
var find$1 = function (regexes, agent) {
var r = firstMatch(regexes, agent);
if (!r)
return {
major: 0,
minor: 0
};
var group = function (i) {
return Number(agent.replace(r, '$' + i));
};
return nu(group(1), group(2));
};
var detect = function (versionRegexes, agent) {
var cleanedAgent = String(agent).toLowerCase();
if (versionRegexes.length === 0)
return unknown();
return find$1(versionRegexes, cleanedAgent);
};
var unknown = function () {
return nu(0, 0);
};
var nu = function (major, minor) {
return {
major: major,
minor: minor
};
};
var Version = {
nu: nu,
detect: detect,
unknown: unknown
};
var edge = 'Edge';
var chrome = 'Chrome';
var ie = 'IE';
var opera = 'Opera';
var firefox = 'Firefox';
var safari = 'Safari';
var isBrowser = function (name, current) {
return function () {
return current === name;
};
};
var unknown$1 = function () {
return nu$1({
current: undefined,
version: Version.unknown()
});
};
var nu$1 = function (info) {
var current = info.current;
var version = info.version;
return {
current: current,
version: version,
isEdge: isBrowser(edge, current),
isChrome: isBrowser(chrome, current),
isIE: isBrowser(ie, current),
isOpera: isBrowser(opera, current),
isFirefox: isBrowser(firefox, current),
isSafari: isBrowser(safari, current)
};
};
var Browser = {
unknown: unknown$1,
nu: nu$1,
edge: constant(edge),
chrome: constant(chrome),
ie: constant(ie),
opera: constant(opera),
firefox: constant(firefox),
safari: constant(safari)
};
var windows = 'Windows';
var ios = 'iOS';
var android = 'Android';
var linux = 'Linux';
var osx = 'OSX';
var solaris = 'Solaris';
var freebsd = 'FreeBSD';
var isOS = function (name, current) {
return function () {
return current === name;
};
};
var unknown$2 = function () {
return nu$2({
current: undefined,
version: Version.unknown()
});
};
var nu$2 = function (info) {
var current = info.current;
var version = info.version;
return {
current: current,
version: version,
isWindows: isOS(windows, current),
isiOS: isOS(ios, current),
isAndroid: isOS(android, current),
isOSX: isOS(osx, current),
isLinux: isOS(linux, current),
isSolaris: isOS(solaris, current),
isFreeBSD: isOS(freebsd, current)
};
};
var OperatingSystem = {
unknown: unknown$2,
nu: nu$2,
windows: constant(windows),
ios: constant(ios),
android: constant(android),
linux: constant(linux),
osx: constant(osx),
solaris: constant(solaris),
freebsd: constant(freebsd)
};
var DeviceType = function (os, browser, userAgent) {
var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
var isiPhone = os.isiOS() && !isiPad;
var isAndroid3 = os.isAndroid() && os.version.major === 3;
var isAndroid4 = os.isAndroid() && os.version.major === 4;
var isTablet = isiPad || isAndroid3 || isAndroid4 && /mobile/i.test(userAgent) === true;
var isTouch = os.isiOS() || os.isAndroid();
var isPhone = isTouch && !isTablet;
var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
return {
isiPad: constant(isiPad),
isiPhone: constant(isiPhone),
isTablet: constant(isTablet),
isPhone: constant(isPhone),
isTouch: constant(isTouch),
isAndroid: os.isAndroid,
isiOS: os.isiOS,
isWebView: constant(iOSwebview)
};
};
var rawIndexOf = function () {
var pIndexOf = Array.prototype.indexOf;
var fastIndex = function (xs, x) {
return pIndexOf.call(xs, x);
};
var slowIndex = function (xs, x) {
return slowIndexOf(xs, x);
};
return pIndexOf === undefined ? slowIndex : fastIndex;
}();
var contains = function (xs, x) {
return rawIndexOf(xs, x) > -1;
};
var exists = function (xs, pred) {
return findIndex(xs, pred).isSome();
};
var map$1 = function (xs, f) {
var len = xs.length;
var r = new Array(len);
for (var i = 0; i < len; i++) {
var x = xs[i];
r[i] = f(x, i, xs);
}
return r;
};
var each$1 = function (xs, f) {
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
f(x, i, xs);
}
};
var eachr = function (xs, f) {
for (var i = xs.length - 1; i >= 0; i--) {
var x = xs[i];
f(x, i, xs);
}
};
var filter = function (xs, pred) {
var r = [];
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
if (pred(x, i, xs)) {
r.push(x);
}
}
return r;
};
var foldr = function (xs, f, acc) {
eachr(xs, function (x) {
acc = f(acc, x);
});
return acc;
};
var foldl = function (xs, f, acc) {
each$1(xs, function (x) {
acc = f(acc, x);
});
return acc;
};
var find$2 = function (xs, pred) {
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
if (pred(x, i, xs)) {
return Option.some(x);
}
}
return Option.none();
};
var findIndex = function (xs, pred) {
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
if (pred(x, i, xs)) {
return Option.some(i);
}
}
return Option.none();
};
var slowIndexOf = function (xs, x) {
for (var i = 0, len = xs.length; i < len; ++i) {
if (xs[i] === x) {
return i;
}
}
return -1;
};
var push = Array.prototype.push;
var flatten = function (xs) {
var r = [];
for (var i = 0, len = xs.length; i < len; ++i) {
if (!Array.prototype.isPrototypeOf(xs[i]))
throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
push.apply(r, xs[i]);
}
return r;
};
var bind = function (xs, f) {
var output = map$1(xs, f);
return flatten(output);
};
var forall = function (xs, pred) {
for (var i = 0, len = xs.length; i < len; ++i) {
var x = xs[i];
if (pred(x, i, xs) !== true) {
return false;
}
}
return true;
};
var slice = Array.prototype.slice;
var reverse = function (xs) {
var r = slice.call(xs, 0);
r.reverse();
return r;
};
var difference = function (a1, a2) {
return filter(a1, function (x) {
return !contains(a2, x);
});
};
var pure = function (x) {
return [x];
};
var from$1 = isFunction(Array.from) ? Array.from : function (x) {
return slice.call(x);
};
var detect$1 = function (candidates, userAgent) {
var agent = String(userAgent).toLowerCase();
return find$2(candidates, function (candidate) {
return candidate.search(agent);
});
};
var detectBrowser = function (browsers, userAgent) {
return detect$1(browsers, userAgent).map(function (browser) {
var version = Version.detect(browser.versionRegexes, userAgent);
return {
current: browser.name,
version: version
};
});
};
var detectOs = function (oses, userAgent) {
return detect$1(oses, userAgent).map(function (os) {
var version = Version.detect(os.versionRegexes, userAgent);
return {
current: os.name,
version: version
};
});
};
var UaString = {
detectBrowser: detectBrowser,
detectOs: detectOs
};
var checkRange = function (str, substr, start) {
if (substr === '')
return true;
if (str.length < substr.length)
return false;
var x = str.substr(start, start + substr.length);
return x === substr;
};
var supplant = function (str, obj) {
var isStringOrNumber = function (a) {
var t = typeof a;
return t === 'string' || t === 'number';
};
return str.replace(/\$\{([^{}]*)\}/g, function (fullMatch, key) {
var value = obj[key];
return isStringOrNumber(value) ? value.toString() : fullMatch;
});
};
var contains$1 = function (str, substr) {
return str.indexOf(substr) !== -1;
};
var endsWith = function (str, suffix) {
return checkRange(str, suffix, str.length - suffix.length);
};
var trim = function (str) {
return str.replace(/^\s+|\s+$/g, '');
};
var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
var checkContains = function (target) {
return function (uastring) {
return contains$1(uastring, target);
};
};
var browsers = [
{
name: 'Edge',
versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
search: function (uastring) {
var monstrosity = contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit');
return monstrosity;
}
},
{
name: 'Chrome',
versionRegexes: [
/.*?chrome\/([0-9]+)\.([0-9]+).*/,
normalVersionRegex
],
search: function (uastring) {
return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe');
}
},
{
name: 'IE',
versionRegexes: [
/.*?msie\ ?([0-9]+)\.([0-9]+).*/,
/.*?rv:([0-9]+)\.([0-9]+).*/
],
search: function (uastring) {
return contains$1(uastring, 'msie') || contains$1(uastring, 'trident');
}
},
{
name: 'Opera',
versionRegexes: [
normalVersionRegex,
/.*?opera\/([0-9]+)\.([0-9]+).*/
],
search: checkContains('opera')
},
{
name: 'Firefox',
versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
search: checkContains('firefox')
},
{
name: 'Safari',
versionRegexes: [
normalVersionRegex,
/.*?cpu os ([0-9]+)_([0-9]+).*/
],
search: function (uastring) {
return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit');
}
}
];
var oses = [
{
name: 'Windows',
search: checkContains('win'),
versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
},
{
name: 'iOS',
search: function (uastring) {
return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad');
},
versionRegexes: [
/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
/.*cpu os ([0-9]+)_([0-9]+).*/,
/.*cpu iphone os ([0-9]+)_([0-9]+).*/
]
},
{
name: 'Android',
search: checkContains('android'),
versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
},
{
name: 'OSX',
search: checkContains('os x'),
versionRegexes: [/.*?os\ x\ ?([0-9]+)_([0-9]+).*/]
},
{
name: 'Linux',
search: checkContains('linux'),
versionRegexes: []
},
{
name: 'Solaris',
search: checkContains('sunos'),
versionRegexes: []
},
{
name: 'FreeBSD',
search: checkContains('freebsd'),
versionRegexes: []
}
];
var PlatformInfo = {
browsers: constant(browsers),
oses: constant(oses)
};
var detect$2 = function (userAgent) {
var browsers = PlatformInfo.browsers();
var oses = PlatformInfo.oses();
var browser = UaString.detectBrowser(browsers, userAgent).fold(Browser.unknown, Browser.nu);
var os = UaString.detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
var deviceType = DeviceType(os, browser, userAgent);
return {
browser: browser,
os: os,
deviceType: deviceType
};
};
var PlatformDetection = { detect: detect$2 };
var detect$3 = cached(function () {
var userAgent = navigator.userAgent;
return PlatformDetection.detect(userAgent);
});
var $_cm7go1y5jnlpb6bj = { detect: detect$3 };
var alloy = { tap: constant('alloy.tap') };
var focus$1 = constant('alloy.focus');
var postBlur = constant('alloy.blur.post');
var receive = constant('alloy.receive');
var execute = constant('alloy.execute');
var focusItem = constant('alloy.focus.item');
var tap = alloy.tap;
var tapOrClick = $_cm7go1y5jnlpb6bj.detect().deviceType.isTouch() ? alloy.tap : click;
var longpress = constant('alloy.longpress');
var systemInit = constant('alloy.system.init');
var windowScroll = constant('alloy.system.scroll');
var attachedToDom = constant('alloy.system.attached');
var detachedFromDom = constant('alloy.system.detached');
var emit = function (component, event) {
dispatchWith(component, component.element(), event, {});
};
var emitWith = function (component, event, properties) {
dispatchWith(component, component.element(), event, properties);
};
var emitExecute = function (component) {
emit(component, execute());
};
var dispatch = function (component, target, event) {
dispatchWith(component, target, event, {});
};
var dispatchWith = function (component, target, event, properties) {
var data = deepMerge({ target: target }, properties);
component.getSystem().triggerEvent(event, target, map(data, constant));
};
var dispatchEvent = function (component, target, event, simulatedEvent) {
component.getSystem().triggerEvent(event, target, simulatedEvent.event());
};
var dispatchFocus = function (component, target) {
component.getSystem().triggerFocus(target, component.element());
};
var fromHtml = function (html, scope) {
var doc = scope || document;
var div = doc.createElement('div');
div.innerHTML = html;
if (!div.hasChildNodes() || div.childNodes.length > 1) {
console.error('HTML does not have a single root node', html);
throw 'HTML must have a single root node';
}
return fromDom(div.childNodes[0]);
};
var fromTag = function (tag, scope) {
var doc = scope || document;
var node = doc.createElement(tag);
return fromDom(node);
};
var fromText = function (text, scope) {
var doc = scope || document;
var node = doc.createTextNode(text);
return fromDom(node);
};
var fromDom = function (node) {
if (node === null || node === undefined)
throw new Error('Node cannot be null or undefined');
return { dom: constant(node) };
};
var fromPoint = function (docElm, x, y) {
var doc = docElm.dom();
return Option.from(doc.elementFromPoint(x, y)).map(fromDom);
};
var Element$$1 = {
fromHtml: fromHtml,
fromTag: fromTag,
fromText: fromText,
fromDom: fromDom,
fromPoint: fromPoint
};
var $_rsjcxynjnlpb6dy = {
ATTRIBUTE: Node.ATTRIBUTE_NODE,
CDATA_SECTION: Node.CDATA_SECTION_NODE,
COMMENT: Node.COMMENT_NODE,
DOCUMENT: Node.DOCUMENT_NODE,
DOCUMENT_TYPE: Node.DOCUMENT_TYPE_NODE,
DOCUMENT_FRAGMENT: Node.DOCUMENT_FRAGMENT_NODE,
ELEMENT: Node.ELEMENT_NODE,
TEXT: Node.TEXT_NODE,
PROCESSING_INSTRUCTION: Node.PROCESSING_INSTRUCTION_NODE,
ENTITY_REFERENCE: Node.ENTITY_REFERENCE_NODE,
ENTITY: Node.ENTITY_NODE,
NOTATION: Node.NOTATION_NODE
};
var name = function (element) {
var r = element.dom().nodeName;
return r.toLowerCase();
};
var type = function (element) {
return element.dom().nodeType;
};
var value = function (element) {
return element.dom().nodeValue;
};
var isType$1 = function (t) {
return function (element) {
return type(element) === t;
};
};
var isComment = function (element) {
return type(element) === $_rsjcxynjnlpb6dy.COMMENT || name(element) === '#comment';
};
var isElement = isType$1($_rsjcxynjnlpb6dy.ELEMENT);
var isText = isType$1($_rsjcxynjnlpb6dy.TEXT);
var isDocument = isType$1($_rsjcxynjnlpb6dy.DOCUMENT);
var $_e4kwzlymjnlpb6dx = {
name: name,
type: type,
value: value,
isElement: isElement,
isText: isText,
isDocument: isDocument,
isComment: isComment
};
var inBody = function (element) {
var dom = $_e4kwzlymjnlpb6dx.isText(element) ? element.dom().parentNode : element.dom();
return dom !== undefined && dom !== null && dom.ownerDocument.body.contains(dom);
};
var body = cached(function () {
return getBody(Element$$1.fromDom(document));
});
var getBody = function (doc) {
var body = doc.dom().body;
if (body === null || body === undefined)
throw 'Body is not available yet';
return Element$$1.fromDom(body);
};
var $_80aql3ykjnlpb6dm = {
body: body,
getBody: getBody,
inBody: inBody
};
var Immutable = function () {
var fields = [];
for (var _i = 0; _i < arguments.length; _i++) {
fields[_i] = arguments[_i];
}
return function () {
var values = [];
for (var _i = 0; _i < arguments.length; _i++) {
values[_i] = arguments[_i];
}
if (fields.length !== values.length) {
throw new Error('Wrong number of arguments to struct. Expected "[' + fields.length + ']", got ' + values.length + ' arguments');
}
var struct = {};
each$1(fields, function (name, i) {
struct[name] = constant(values[i]);
});
return struct;
};
};
var sort$1 = function (arr) {
return arr.slice(0).sort();
};
var reqMessage = function (required, keys) {
throw new Error('All required keys (' + sort$1(required).join(', ') + ') were not specified. Specified keys were: ' + sort$1(keys).join(', ') + '.');
};
var unsuppMessage = function (unsupported) {
throw new Error('Unsupported keys for object: ' + sort$1(unsupported).join(', '));
};
var validateStrArr = function (label, array) {
if (!isArray(array))
throw new Error('The ' + label + ' fields must be an array. Was: ' + array + '.');
each$1(array, function (a) {
if (!isString(a))
throw new Error('The value ' + a + ' in the ' + label + ' fields was not a string.');
});
};
var invalidTypeMessage = function (incorrect, type) {
throw new Error('All values need to be of type: ' + type + '. Keys (' + sort$1(incorrect).join(', ') + ') were not.');
};
var checkDupes = function (everything) {
var sorted = sort$1(everything);
var dupe = find$2(sorted, function (s, i) {
return i < sorted.length - 1 && s === sorted[i + 1];
});
dupe.each(function (d) {
throw new Error('The field: ' + d + ' occurs more than once in the combined fields: [' + sorted.join(', ') + '].');
});
};
var MixedBag = function (required, optional) {
var everything = required.concat(optional);
if (everything.length === 0)
throw new Error('You must specify at least one required or optional field.');
validateStrArr('required', required);
validateStrArr('optional', optional);
checkDupes(everything);
return function (obj) {
var keys$$1 = keys(obj);
var allReqd = forall(required, function (req) {
return contains(keys$$1, req);
});
if (!allReqd)
reqMessage(required, keys$$1);
var unsupported = filter(keys$$1, function (key) {
return !contains(everything, key);
});
if (unsupported.length > 0)
unsuppMessage(unsupported);
var r = {};
each$1(required, function (req) {
r[req] = constant(obj[req]);
});
each$1(optional, function (opt) {
r[opt] = constant(Object.prototype.hasOwnProperty.call(obj, opt) ? Option.some(obj[opt]) : Option.none());
});
return r;
};
};
var toArray = function (target, f) {
var r = [];
var recurse = function (e) {
r.push(e);
return f(e);
};
var cur = f(target);
do {
cur = cur.bind(recurse);
} while (cur.isSome());
return r;
};
var $_8pkvx2yujnlpb6ek = { toArray: toArray };
var Global = typeof window !== 'undefined' ? window : Function('return this;')();
var path = function (parts, scope) {
var o = scope !== undefined && scope !== null ? scope : Global;
for (var i = 0; i < parts.length && o !== undefined && o !== null; ++i)
o = o[parts[i]];
return o;
};
var resolve = function (p, scope) {
var parts = p.split('.');
return path(parts, scope);
};
var unsafe = function (name, scope) {
return resolve(name, scope);
};
var getOrDie = function (name, scope) {
var actual = unsafe(name, scope);
if (actual === undefined || actual === null)
throw name + ' not available on this browser';
return actual;
};
var $_cb5h6nyxjnlpb6f1 = { getOrDie: getOrDie };
var node = function () {
var f = $_cb5h6nyxjnlpb6f1.getOrDie('Node');
return f;
};
var compareDocumentPosition = function (a, b, match) {
return (a.compareDocumentPosition(b) & match) !== 0;
};
var documentPositionPreceding = function (a, b) {
return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_PRECEDING);
};
var documentPositionContainedBy = function (a, b) {
return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_CONTAINED_BY);
};
var $_e9u16zywjnlpb6f0 = {
documentPositionPreceding: documentPositionPreceding,
documentPositionContainedBy: documentPositionContainedBy
};
var ELEMENT = $_rsjcxynjnlpb6dy.ELEMENT;
var DOCUMENT = $_rsjcxynjnlpb6dy.DOCUMENT;
var is = function (element, selector) {
var elem = element.dom();
if (elem.nodeType !== ELEMENT)
return false;
else if (elem.matches !== undefined)
return elem.matches(selector);
else if (elem.msMatchesSelector !== undefined)
return elem.msMatchesSelector(selector);
else if (elem.webkitMatchesSelector !== undefined)
return elem.webkitMatchesSelector(selector);
else if (elem.mozMatchesSelector !== undefined)
return elem.mozMatchesSelector(selector);
else
throw new Error('Browser lacks native selectors');
};
var bypassSelector = function (dom) {
return dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT || dom.childElementCount === 0;
};
var all = function (selector, scope) {
var base = scope === undefined ? document : scope.dom();
return bypassSelector(base) ? [] : map$1(base.querySelectorAll(selector), Element$$1.fromDom);
};
var one = function (selector, scope) {
var base = scope === undefined ? document : scope.dom();
return bypassSelector(base) ? Option.none() : Option.from(base.querySelector(selector)).map(Element$$1.fromDom);
};
var $_b1wn16z0jnlpb6f6 = {
all: all,
is: is,
one: one
};
var eq = function (e1, e2) {
return e1.dom() === e2.dom();
};
var isEqualNode = function (e1, e2) {
return e1.dom().isEqualNode(e2.dom());
};
var member = function (element, elements) {
return exists(elements, curry(eq, element));
};
var regularContains = function (e1, e2) {
var d1 = e1.dom(), d2 = e2.dom();
return d1 === d2 ? false : d1.contains(d2);
};
var ieContains = function (e1, e2) {
return $_e9u16zywjnlpb6f0.documentPositionContainedBy(e1.dom(), e2.dom());
};
var browser = $_cm7go1y5jnlpb6bj.detect().browser;
var contains$2 = browser.isIE() ? ieContains : regularContains;
var $_50rqllyvjnlpb6el = {
eq: eq,
isEqualNode: isEqualNode,
member: member,
contains: contains$2,
is: $_b1wn16z0jnlpb6f6.is
};
var owner = function (element) {
return Element$$1.fromDom(element.dom().ownerDocument);
};
var documentElement = function (element) {
return Element$$1.fromDom(element.dom().ownerDocument.documentElement);
};
var defaultView = function (element) {
var el = element.dom();
var defaultView = el.ownerDocument.defaultView;
return Element$$1.fromDom(defaultView);
};
var parent = function (element) {
var dom = element.dom();
return Option.from(dom.parentNode).map(Element$$1.fromDom);
};
var findIndex$1 = function (element) {
return parent(element).bind(function (p) {
var kin = children(p);
return findIndex(kin, function (elem) {
return $_50rqllyvjnlpb6el.eq(element, elem);
});
});
};
var parents = function (element, isRoot) {
var stop = isFunction(isRoot) ? isRoot : constant(false);
var dom = element.dom();
var ret = [];
while (dom.parentNode !== null && dom.parentNode !== undefined) {
var rawParent = dom.parentNode;
var parent = Element$$1.fromDom(rawParent);
ret.push(parent);
if (stop(parent) === true)
break;
else
dom = rawParent;
}
return ret;
};
var siblings = function (element) {
var filterSelf = function (elements) {
return filter(elements, function (x) {
return !$_50rqllyvjnlpb6el.eq(element, x);
});
};
return parent(element).map(children).map(filterSelf).getOr([]);
};
var offsetParent = function (element) {
var dom = element.dom();
return Option.from(dom.offsetParent).map(Element$$1.fromDom);
};
var prevSibling = function (element) {
var dom = element.dom();
return Option.from(dom.previousSibling).map(Element$$1.fromDom);
};
var nextSibling = function (element) {
var dom = element.dom();
return Option.from(dom.nextSibling).map(Element$$1.fromDom);
};
var prevSiblings = function (element) {
return reverse($_8pkvx2yujnlpb6ek.toArray(element, prevSibling));
};
var nextSiblings = function (element) {
return $_8pkvx2yujnlpb6ek.toArray(element, nextSibling);
};
var children = function (element) {
var dom = element.dom();
return map$1(dom.childNodes, Element$$1.fromDom);
};
var child = function (element, index) {
var children = element.dom().childNodes;
return Option.from(children[index]).map(Element$$1.fromDom);
};
var firstChild = function (element) {
return child(element, 0);
};
var lastChild = function (element) {
return child(element, element.dom().childNodes.length - 1);
};
var childNodesCount = function (element) {
return element.dom().childNodes.length;
};
var hasChildNodes = function (element) {
return element.dom().hasChildNodes();
};
var spot = Immutable('element', 'offset');
var leaf = function (element, offset) {
var cs = children(element);
return cs.length > 0 && offset < cs.length ? spot(cs[offset], 0) : spot(element, offset);
};
var $_ed6t6dypjnlpb6e2 = {
owner: owner,
defaultView: defaultView,
documentElement: documentElement,
parent: parent,
findIndex: findIndex$1,
parents: parents,
siblings: siblings,
prevSibling: prevSibling,
offsetParent: offsetParent,
prevSiblings: prevSiblings,
nextSibling: nextSibling,
nextSiblings: nextSiblings,
children: children,
child: child,
firstChild: firstChild,
lastChild: lastChild,
childNodesCount: childNodesCount,
hasChildNodes: hasChildNodes,
leaf: leaf
};
var before = function (marker, element) {
var parent = $_ed6t6dypjnlpb6e2.parent(marker);
parent.each(function (v) {
v.dom().insertBefore(element.dom(), marker.dom());
});
};
var after = function (marker, element) {
var sibling = $_ed6t6dypjnlpb6e2.nextSibling(marker);
sibling.fold(function () {
var parent = $_ed6t6dypjnlpb6e2.parent(marker);
parent.each(function (v) {
append(v, element);
});
}, function (v) {
before(v, element);
});
};
var prepend = function (parent, element) {
var firstChild = $_ed6t6dypjnlpb6e2.firstChild(parent);
firstChild.fold(function () {
append(parent, element);
}, function (v) {
parent.dom().insertBefore(element.dom(), v.dom());
});
};
var append = function (parent, element) {
parent.dom().appendChild(element.dom());
};
var appendAt = function (parent, element, index) {
$_ed6t6dypjnlpb6e2.child(parent, index).fold(function () {
append(parent, element);
}, function (v) {
before(v, element);
});
};
var wrap = function (element, wrapper) {
before(element, wrapper);
append(wrapper, element);
};
var $_4xxatsyojnlpb6e0 = {
before: before,
after: after,
prepend: prepend,
append: append,
appendAt: appendAt,
wrap: wrap
};
var before$1 = function (marker, elements) {
each$1(elements, function (x) {
$_4xxatsyojnlpb6e0.before(marker, x);
});
};
var after$1 = function (marker, elements) {
each$1(elements, function (x, i) {
var e = i === 0 ? marker : elements[i - 1];
$_4xxatsyojnlpb6e0.after(e, x);
});
};
var prepend$1 = function (parent, elements) {
each$1(elements.slice().reverse(), function (x) {
$_4xxatsyojnlpb6e0.prepend(parent, x);
});
};
var append$1 = function (parent, elements) {
each$1(elements, function (x) {
$_4xxatsyojnlpb6e0.append(parent, x);
});
};
var $_az2xmdz2jnlpb6fg = {
before: before$1,
after: after$1,
prepend: prepend$1,
append: append$1
};
var empty = function (element) {
element.dom().textContent = '';
each$1($_ed6t6dypjnlpb6e2.children(element), function (rogue) {
remove(rogue);
});
};
var remove = function (element) {
var dom = element.dom();
if (dom.parentNode !== null)
dom.parentNode.removeChild(dom);
};
var unwrap = function (wrapper) {
var children = $_ed6t6dypjnlpb6e2.children(wrapper);
if (children.length > 0)
$_az2xmdz2jnlpb6fg.before(wrapper, children);
remove(wrapper);
};
var $_1k5796z1jnlpb6fd = {
empty: empty,
remove: remove,
unwrap: unwrap
};
var fireDetaching = function (component) {
emit(component, detachedFromDom());
var children = component.components();
each$1(children, fireDetaching);
};
var fireAttaching = function (component) {
var children = component.components();
each$1(children, fireAttaching);
emit(component, attachedToDom());
};
var attach = function (parent, child) {
attachWith(parent, child, $_4xxatsyojnlpb6e0.append);
};
var attachWith = function (parent, child, insertion) {
parent.getSystem().addToWorld(child);
insertion(parent.element(), child.element());
if ($_80aql3ykjnlpb6dm.inBody(parent.element())) {
fireAttaching(child);
}
parent.syncComponents();
};
var doDetach = function (component) {
fireDetaching(component);
$_1k5796z1jnlpb6fd.remove(component.element());
component.getSystem().removeFromWorld(component);
};
var detach = function (component) {
var parent = $_ed6t6dypjnlpb6e2.parent(component.element()).bind(function (p) {
return component.getSystem().getByDom(p).fold(Option.none, Option.some);
});
doDetach(component);
parent.each(function (p) {
p.syncComponents();
});
};
var detachChildren = function (component) {
var subs = component.components();
each$1(subs, doDetach);
$_1k5796z1jnlpb6fd.empty(component.element());
component.syncComponents();
};
var attachSystem = function (element, guiSystem) {
$_4xxatsyojnlpb6e0.append(element, guiSystem.element());
var children = $_ed6t6dypjnlpb6e2.children(guiSystem.element());
each$1(children, function (child) {
guiSystem.getByDom(child).each(fireAttaching);
});
};
var value$1 = function (o) {
var is = function (v) {
return o === v;
};
var or = function (opt) {
return value$1(o);
};
var orThunk = function (f) {
return value$1(o);
};
var map = function (f) {
return value$1(f(o));
};
var each = function (f) {
f(o);
};
var bind = function (f) {
return f(o);
};
var fold = function (_, onValue) {
return onValue(o);
};
var exists = function (f) {
return f(o);
};
var forall = function (f) {
return f(o);
};
var toOption = function () {
return Option.some(o);
};
return {
is: is,
isValue: always,
isError: never,
getOr: constant(o),
getOrThunk: constant(o),
getOrDie: constant(o),
or: or,
orThunk: orThunk,
fold: fold,
map: map,
each: each,
bind: bind,
exists: exists,
forall: forall,
toOption: toOption
};
};
var error = function (message) {
var getOrThunk = function (f) {
return f();
};
var getOrDie = function () {
return die(String(message))();
};
var or = function (opt) {
return opt;
};
var orThunk = function (f) {
return f();
};
var map = function (f) {
return error(message);
};
var bind = function (f) {
return error(message);
};
var fold = function (onError, _) {
return onError(message);
};
return {
is: never,
isValue: never,
isError: always,
getOr: identity,
getOrThunk: getOrThunk,
getOrDie: getOrDie,
or: or,
orThunk: orThunk,
fold: fold,
map: map,
each: noop,
bind: bind,
exists: never,
forall: always,
toOption: Option.none
};
};
var Result = {
value: value$1,
error: error
};
var generate = function (cases) {
if (!isArray(cases)) {
throw new Error('cases must be an array');
}
if (cases.length === 0) {
throw new Error('there must be at least one case');
}
var constructors = [];
var adt = {};
each$1(cases, function (acase, count) {
var keys$$1 = keys(acase);
if (keys$$1.length !== 1) {
throw new Error('one and only one name per case');
}
var key = keys$$1[0];
var value = acase[key];
if (adt[key] !== undefined) {
throw new Error('duplicate key detected:' + key);
} else if (key === 'cata') {
throw new Error('cannot have a case named cata (sorry)');
} else if (!isArray(value)) {
throw new Error('case arguments must be an array');
}
constructors.push(key);
adt[key] = function () {
var argLength = arguments.length;
if (argLength !== value.length) {
throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength);
}
var args = new Array(argLength);
for (var i = 0; i < args.length; i++)
args[i] = arguments[i];
var match = function (branches) {
var branchKeys = keys(branches);
if (constructors.length !== branchKeys.length) {
throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(','));
}
var allReqd = forall(constructors, function (reqKey) {
return contains(branchKeys, reqKey);
});
if (!allReqd)
throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', '));
return branches[key].apply(null, args);
};
return {
fold: function () {
if (arguments.length !== cases.length) {
throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + arguments.length);
}
var target = arguments[count];
return target.apply(null, args);
},
match: match,
log: function (label) {
console.log(label, {
constructors: constructors,
constructor: key,
params: args
});
}
};
};
});
return adt;
};
var Adt = { generate: generate };
var adt = Adt.generate([
{ strict: [] },
{ defaultedThunk: ['fallbackThunk'] },
{ asOption: [] },
{ asDefaultedOptionThunk: ['fallbackThunk'] },
{ mergeWithThunk: ['baseThunk'] }
]);
var defaulted = function (fallback) {
return adt.defaultedThunk(constant(fallback));
};
var mergeWith = function (base) {
return adt.mergeWithThunk(constant(base));
};
var strict = adt.strict;
var asOption = adt.asOption;
var defaultedThunk = adt.defaultedThunk;
var asDefaultedOptionThunk = adt.asDefaultedOptionThunk;
var mergeWithThunk = adt.mergeWithThunk;
var comparison = Adt.generate([
{
bothErrors: [
'error1',
'error2'
]
},
{
firstError: [
'error1',
'value2'
]
},
{
secondError: [
'value1',
'error2'
]
},
{
bothValues: [
'value1',
'value2'
]
}
]);
var partition$1 = function (results) {
var errors = [];
var values = [];
each$1(results, function (result) {
result.fold(function (err) {
errors.push(err);
}, function (value) {
values.push(value);
});
});
return {
errors: errors,
values: values
};
};
var mergeValues = function (values, base) {
return Result.value(deepMerge.apply(undefined, [base].concat(values)));
};
var mergeErrors = function (errors) {
return compose(Result.error, flatten)(errors);
};
var consolidateObj = function (objects, base) {
var partitions = partition$1(objects);
return partitions.errors.length > 0 ? mergeErrors(partitions.errors) : mergeValues(partitions.values, base);
};
var consolidateArr = function (objects) {
var partitions = partition$1(objects);
return partitions.errors.length > 0 ? mergeErrors(partitions.errors) : Result.value(partitions.values);
};
var ResultCombine = {
consolidateObj: consolidateObj,
consolidateArr: consolidateArr
};
var narrow = function (obj, fields) {
var r = {};
each$1(fields, function (field) {
if (obj[field] !== undefined && obj.hasOwnProperty(field)) {
r[field] = obj[field];
}
});
return r;
};
var exclude = function (obj, fields) {
var r = {};
each(obj, function (v, k) {
if (!contains(fields, k)) {
r[k] = v;
}
});
return r;
};
var readOpt = function (key) {
return function (obj) {
return obj.hasOwnProperty(key) ? Option.from(obj[key]) : Option.none();
};
};
var readOr = function (key, fallback) {
return function (obj) {
return readOpt(key)(obj).getOr(fallback);
};
};
var readOptFrom = function (obj, key) {
return readOpt(key)(obj);
};
var hasKey = function (obj, key) {
return obj.hasOwnProperty(key) && obj[key] !== undefined && obj[key] !== null;
};
var wrap$1 = function (key, value) {
var r = {};
r[key] = value;
return r;
};
var wrapAll = function (keyvalues) {
var r = {};
each$1(keyvalues, function (kv) {
r[kv.key] = kv.value;
});
return r;
};
var narrow$1 = function (obj, fields) {
return narrow(obj, fields);
};
var exclude$1 = function (obj, fields) {
return exclude(obj, fields);
};
var readOpt$1 = function (key) {
return readOpt(key);
};
var readOr$1 = function (key, fallback) {
return readOr(key, fallback);
};
var readOptFrom$1 = function (obj, key) {
return readOptFrom(obj, key);
};
var wrap$2 = function (key, value) {
return wrap$1(key, value);
};
var wrapAll$1 = function (keyvalues) {
return wrapAll(keyvalues);
};
var consolidate = function (objs, base) {
return ResultCombine.consolidateObj(objs, base);
};
var hasKey$1 = function (obj, key) {
return hasKey(obj, key);
};
var typeAdt = Adt.generate([
{
setOf: [
'validator',
'valueType'
]
},
{ arrOf: ['valueType'] },
{ objOf: ['fields'] },
{ itemOf: ['validator'] },
{
choiceOf: [
'key',
'branches'
]
},
{ thunk: ['description'] },
{
func: [
'args',
'outputSchema'
]
}
]);
var fieldAdt = Adt.generate([
{
field: [
'name',
'presence',
'type'
]
},
{ state: ['name'] }
]);
var json = function () {
return $_cb5h6nyxjnlpb6f1.getOrDie('JSON');
};
var parse = function (text) {
return json().parse(text);
};
var stringify = function (obj, replacer, space) {
return json().stringify(obj, replacer, space);
};
var $_4h6rd7zjjnlpb6ii = {
parse: parse,
stringify: stringify
};
var formatObj = function (input) {
return isObject(input) && keys(input).length > 100 ? ' removed due to size' : $_4h6rd7zjjnlpb6ii.stringify(input, null, 2);
};
var formatErrors = function (errors) {
var es = errors.length > 10 ? errors.slice(0, 10).concat([{
path: [],
getErrorInfo: function () {
return '... (only showing first ten failures)';
}
}]) : errors;
return map$1(es, function (e) {
return 'Failed path: (' + e.path.join(' > ') + ')\n' + e.getErrorInfo();
});
};
var nu$3 = function (path, getErrorInfo) {
return Result.error([{
path: path,
getErrorInfo: getErrorInfo
}]);
};
var missingStrict = function (path, key, obj) {
return nu$3(path, function () {
return 'Could not find valid *strict* value for "' + key + '" in ' + formatObj(obj);
});
};
var missingKey = function (path, key) {
return nu$3(path, function () {
return 'Choice schema did not contain choice key: "' + key + '"';
});
};
var missingBranch = function (path, branches, branch) {
return nu$3(path, function () {
return 'The chosen schema: "' + branch + '" did not exist in branches: ' + formatObj(branches);
});
};
var unsupportedFields = function (path, unsupported) {
return nu$3(path, function () {
return 'There are unsupported fields: [' + unsupported.join(', ') + '] specified';
});
};
var custom = function (path, err) {
return nu$3(path, function () {
return err;
});
};
var adt$1 = Adt.generate([
{
field: [
'key',
'okey',
'presence',
'prop'
]
},
{
state: [
'okey',
'instantiator'
]
}
]);
var strictAccess = function (path, obj, key) {
return readOptFrom(obj, key).fold(function () {
return missingStrict(path, key, obj);
}, Result.value);
};
var fallbackAccess = function (obj, key, fallbackThunk) {
var v = readOptFrom(obj, key).fold(function () {
return fallbackT