purescript_web_ext/extension/background.js

// modules are defined as an array
// [ module function, map of requires ]
//
// map of requires is short require name -> numeric require
//
// anything defined in a previous bundle is accessed via the
// orig method which is the require for previous bundles
parcelRequire = (function (modules, cache, entry, globalName) {
  // Save the require from previous bundle to this closure if any
  var previousRequire = typeof parcelRequire === 'function' && parcelRequire;
  var nodeRequire = typeof require === 'function' && require;

  function newRequire(name, jumped) {
    if (!cache[name]) {
      if (!modules[name]) {
        // if we cannot find the module within our internal map or
        // cache jump to the current global require ie. the last bundle
        // that was added to the page.
        var currentRequire = typeof parcelRequire === 'function' && parcelRequire;
        if (!jumped && currentRequire) {
          return currentRequire(name, true);
        }

        // If there are other bundles on this page the require from the
        // previous one is saved to 'previousRequire'. Repeat this as
        // many times as there are bundles until the module is found or
        // we exhaust the require chain.
        if (previousRequire) {
          return previousRequire(name, true);
        }

        // Try the node require function if it exists.
        if (nodeRequire && typeof name === 'string') {
          return nodeRequire(name);
        }

        var err = new Error('Cannot find module \'' + name + '\'');
        err.code = 'MODULE_NOT_FOUND';
        throw err;
      }

      localRequire.resolve = resolve;
      localRequire.cache = {};

      var module = cache[name] = new newRequire.Module(name);

      modules[name][0].call(module.exports, localRequire, module, module.exports, this);
    }

    return cache[name].exports;

    function localRequire(x){
      return newRequire(localRequire.resolve(x));
    }

    function resolve(x){
      return modules[name][1][x] || x;
    }
  }

  function Module(moduleName) {
    this.id = moduleName;
    this.bundle = newRequire;
    this.exports = {};
  }

  newRequire.isParcelRequire = true;
  newRequire.Module = Module;
  newRequire.modules = modules;
  newRequire.cache = cache;
  newRequire.parent = previousRequire;
  newRequire.register = function (id, exports) {
    modules[id] = [function (require, module) {
      module.exports = exports;
    }, {}];
  };

  var error;
  for (var i = 0; i < entry.length; i++) {
    try {
      newRequire(entry[i]);
    } catch (e) {
      // Save first error but execute all entries
      if (!error) {
        error = e;
      }
    }
  }

  if (entry.length) {
    // Expose entry point to Node, AMD or browser globals
    // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
    var mainExports = newRequire(entry[entry.length - 1]);

    // CommonJS
    if (typeof exports === "object" && typeof module !== "undefined") {
      module.exports = mainExports;

    // RequireJS
    } else if (typeof define === "function" && define.amd) {
     define(function () {
       return mainExports;
     });

    // <script>
    } else if (globalName) {
      this[globalName] = mainExports;
    }
  }

  // Override the current require with this new one
  parcelRequire = newRequire;

  if (error) {
    // throw error from earlier, _after updating parcelRequire_
    throw error;
  }

  return newRequire;
})({"../output/Browser.Runtime/foreign.js":[function(require,module,exports) {
"use strict";

exports.connect = function () {
  return browser.runtime.connect({
    name: name
  });
};

exports.postMessage = function (port) {
  return function (message) {
    return function () {
      port.postMessage(message);
    };
  };
};

exports.onConnectAddListener = function (fn) {
  return function () {
    return browser.runtime.onConnect.addListener(function (p) {
      fn(p)();
    });
  };
};

exports.onMessageAddListener = function (port) {
  return function (fn) {
    return function () {
      return port.onMessage.addListener(function (m) {
        return fn(m)();
      });
    };
  };
};
},{}],"../output/Browser.Runtime/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

module.exports = {
  connect: $foreign.connect,
  onConnectAddListener: $foreign.onConnectAddListener,
  postMessage: $foreign.postMessage,
  onMessageAddListener: $foreign.onMessageAddListener
};
},{"./foreign.js":"../output/Browser.Runtime/foreign.js"}],"../output/Browser.Tabs.OnCreated/foreign.js":[function(require,module,exports) {
"use stricts";

exports.mkListener = function (fn) {
  return function () {
    return function (event) {
      return fn(event)();
    };
  };
};

exports.addListener = function (listener) {
  return function () {
    browser.tabs.onCreated.addListener(listener);
  };
};

exports.removeListener = function (listener) {
  return function () {
    return browser.tabs.onCreated.removeListener(listener);
  };
};
},{}],"../output/Browser.Tabs.OnCreated/index.js":[function(require,module,exports) {
"use strict";

var $foreign = require("./foreign.js");

module.exports = {
  mkListener: $foreign.mkListener,
  addListener: $foreign.addListener,
  removeListener: $foreign.removeListener
};
},{"./foreign.js":"../output/Browser.Tabs.OnCreated/foreign.js"}],"../output/Data.Foldable/foreign.js":[function(require,module,exports) {
"use strict";

exports.foldrArray = function (f) {
  return function (init) {
    return function (xs) {
      var acc = init;
      var len = xs.length;

      for (var i = len - 1; i >= 0; i--) {
        acc = f(xs[i])(acc);
      }

      return acc;
    };
  };
};

exports.foldlArray = function (f) {
  return function (init) {
    return function (xs) {
      var acc = init;
      var len = xs.length;

      for (var i = 0; i < len; i++) {
        acc = f(acc)(xs[i]);
      }

      return acc;
    };
  };
};
},{}],"../output/Data.Functor/foreign.js":[function(require,module,exports) {
"use strict";

exports.arrayMap = function (f) {
  return function (arr) {
    var l = arr.length;
    var result = new Array(l);

    for (var i = 0; i < l; i++) {
      result[i] = f(arr[i]);
    }

    return result;
  };
};
},{}],"../output/Control.Semigroupoid/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Semigroupoid = function Semigroupoid(compose) {
  this.compose = compose;
};

var semigroupoidFn = new Semigroupoid(function (f) {
  return function (g) {
    return function (x) {
      return f(g(x));
    };
  };
});

var compose = function compose(dict) {
  return dict.compose;
};

var composeFlipped = function composeFlipped(dictSemigroupoid) {
  return function (f) {
    return function (g) {
      return compose(dictSemigroupoid)(g)(f);
    };
  };
};

module.exports = {
  compose: compose,
  Semigroupoid: Semigroupoid,
  composeFlipped: composeFlipped,
  semigroupoidFn: semigroupoidFn
};
},{}],"../output/Data.Boolean/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var otherwise = true;
module.exports = {
  otherwise: otherwise
};
},{}],"../output/Data.Function/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_Boolean = require("../Data.Boolean/index.js");

var on = function on(f) {
  return function (g) {
    return function (x) {
      return function (y) {
        return f(g(x))(g(y));
      };
    };
  };
};

var flip = function flip(f) {
  return function (b) {
    return function (a) {
      return f(a)(b);
    };
  };
};

var $$const = function $$const(a) {
  return function (v) {
    return a;
  };
};

var applyN = function applyN(f) {
  var go = function go($copy_n) {
    return function ($copy_acc) {
      var $tco_var_n = $copy_n;
      var $tco_done = false;
      var $tco_result;

      function $tco_loop(n, acc) {
        if (n <= 0) {
          $tco_done = true;
          return acc;
        }

        ;

        if (Data_Boolean.otherwise) {
          $tco_var_n = n - 1 | 0;
          $copy_acc = f(acc);
          return;
        }

        ;
        throw new Error("Failed pattern match at Data.Function (line 94, column 3 - line 96, column 37): " + [n.constructor.name, acc.constructor.name]);
      }

      ;

      while (!$tco_done) {
        $tco_result = $tco_loop($tco_var_n, $copy_acc);
      }

      ;
      return $tco_result;
    };
  };

  return go;
};

var applyFlipped = function applyFlipped(x) {
  return function (f) {
    return f(x);
  };
};

var apply = function apply(f) {
  return function (x) {
    return f(x);
  };
};

module.exports = {
  flip: flip,
  "const": $$const,
  apply: apply,
  applyFlipped: applyFlipped,
  applyN: applyN,
  on: on
};
},{"../Data.Boolean/index.js":"../output/Data.Boolean/index.js"}],"../output/Data.Unit/foreign.js":[function(require,module,exports) {
"use strict";

exports.unit = {};
},{}],"../output/Data.Show/foreign.js":[function(require,module,exports) {
"use strict";

exports.showIntImpl = function (n) {
  return n.toString();
};

exports.showNumberImpl = function (n) {
  var str = n.toString();
  return isNaN(str + ".0") ? str : str + ".0";
};

exports.showCharImpl = function (c) {
  var code = c.charCodeAt(0);

  if (code < 0x20 || code === 0x7F) {
    switch (c) {
      case "\x07":
        return "'\\a'";

      case "\b":
        return "'\\b'";

      case "\f":
        return "'\\f'";

      case "\n":
        return "'\\n'";

      case "\r":
        return "'\\r'";

      case "\t":
        return "'\\t'";

      case "\v":
        return "'\\v'";
    }

    return "'\\" + code.toString(10) + "'";
  }

  return c === "'" || c === "\\" ? "'\\" + c + "'" : "'" + c + "'";
};

exports.showStringImpl = function (s) {
  var l = s.length;
  return "\"" + s.replace(/[\0-\x1F\x7F"\\]/g, // eslint-disable-line no-control-regex
  function (c, i) {
    switch (c) {
      case "\"":
      case "\\":
        return "\\" + c;

      case "\x07":
        return "\\a";

      case "\b":
        return "\\b";

      case "\f":
        return "\\f";

      case "\n":
        return "\\n";

      case "\r":
        return "\\r";

      case "\t":
        return "\\t";

      case "\v":
        return "\\v";
    }

    var k = i + 1;
    var empty = k < l && s[k] >= "0" && s[k] <= "9" ? "\\&" : "";
    return "\\" + c.charCodeAt(0).toString(10) + empty;
  }) + "\"";
};

exports.showArrayImpl = function (f) {
  return function (xs) {
    var ss = [];

    for (var i = 0, l = xs.length; i < l; i++) {
      ss[i] = f(xs[i]);
    }

    return "[" + ss.join(",") + "]";
  };
};

exports.cons = function (head) {
  return function (tail) {
    return [head].concat(tail);
  };
};

exports.join = function (separator) {
  return function (xs) {
    return xs.join(separator);
  };
};
},{}],"../output/Data.Symbol/foreign.js":[function(require,module,exports) {
"use strict"; // module Data.Symbol

exports.unsafeCoerce = function (arg) {
  return arg;
};
},{}],"../output/Data.Symbol/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var SProxy = function () {
  function SProxy() {}

  ;
  SProxy.value = new SProxy();
  return SProxy;
}();

var IsSymbol = function IsSymbol(reflectSymbol) {
  this.reflectSymbol = reflectSymbol;
};

var reifySymbol = function reifySymbol(s) {
  return function (f) {
    return $foreign.unsafeCoerce(function (dictIsSymbol) {
      return f(dictIsSymbol);
    })({
      reflectSymbol: function reflectSymbol(v) {
        return s;
      }
    })(SProxy.value);
  };
};

var reflectSymbol = function reflectSymbol(dict) {
  return dict.reflectSymbol;
};

module.exports = {
  IsSymbol: IsSymbol,
  reflectSymbol: reflectSymbol,
  reifySymbol: reifySymbol,
  SProxy: SProxy
};
},{"./foreign.js":"../output/Data.Symbol/foreign.js"}],"../output/Record.Unsafe/foreign.js":[function(require,module,exports) {
"use strict";

exports.unsafeHas = function (label) {
  return function (rec) {
    return {}.hasOwnProperty.call(rec, label);
  };
};

exports.unsafeGet = function (label) {
  return function (rec) {
    return rec[label];
  };
};

exports.unsafeSet = function (label) {
  return function (value) {
    return function (rec) {
      var copy = {};

      for (var key in rec) {
        if ({}.hasOwnProperty.call(rec, key)) {
          copy[key] = rec[key];
        }
      }

      copy[label] = value;
      return copy;
    };
  };
};

exports.unsafeDelete = function (label) {
  return function (rec) {
    var copy = {};

    for (var key in rec) {
      if (key !== label && {}.hasOwnProperty.call(rec, key)) {
        copy[key] = rec[key];
      }
    }

    return copy;
  };
};
},{}],"../output/Record.Unsafe/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

module.exports = {
  unsafeHas: $foreign.unsafeHas,
  unsafeGet: $foreign.unsafeGet,
  unsafeSet: $foreign.unsafeSet,
  unsafeDelete: $foreign.unsafeDelete
};
},{"./foreign.js":"../output/Record.Unsafe/foreign.js"}],"../output/Type.Data.RowList/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var RLProxy = function () {
  function RLProxy() {}

  ;
  RLProxy.value = new RLProxy();
  return RLProxy;
}();

module.exports = {
  RLProxy: RLProxy
};
},{}],"../output/Data.Show/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Symbol = require("../Data.Symbol/index.js");

var Record_Unsafe = require("../Record.Unsafe/index.js");

var Type_Data_RowList = require("../Type.Data.RowList/index.js");

var ShowRecordFields = function ShowRecordFields(showRecordFields) {
  this.showRecordFields = showRecordFields;
};

var Show = function Show(show) {
  this.show = show;
};

var showString = new Show($foreign.showStringImpl);
var showRecordFieldsNil = new ShowRecordFields(function (v) {
  return function (v1) {
    return [];
  };
});

var showRecordFields = function showRecordFields(dict) {
  return dict.showRecordFields;
};

var showRecord = function showRecord(dictRowToList) {
  return function (dictShowRecordFields) {
    return new Show(function (record) {
      var v = showRecordFields(dictShowRecordFields)(Type_Data_RowList.RLProxy.value)(record);

      if (v.length === 0) {
        return "{}";
      }

      ;
      return $foreign.join(" ")(["{", $foreign.join(", ")(v), "}"]);
    });
  };
};

var showNumber = new Show($foreign.showNumberImpl);
var showInt = new Show($foreign.showIntImpl);
var showChar = new Show($foreign.showCharImpl);
var showBoolean = new Show(function (v) {
  if (v) {
    return "true";
  }

  ;

  if (!v) {
    return "false";
  }

  ;
  throw new Error("Failed pattern match at Data.Show (line 20, column 1 - line 22, column 23): " + [v.constructor.name]);
});

var show = function show(dict) {
  return dict.show;
};

var showArray = function showArray(dictShow) {
  return new Show($foreign.showArrayImpl(show(dictShow)));
};

var showRecordFieldsCons = function showRecordFieldsCons(dictIsSymbol) {
  return function (dictShowRecordFields) {
    return function (dictShow) {
      return new ShowRecordFields(function (v) {
        return function (record) {
          var tail = showRecordFields(dictShowRecordFields)(Type_Data_RowList.RLProxy.value)(record);
          var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
          var focus = Record_Unsafe.unsafeGet(key)(record);
          return $foreign.cons($foreign.join(": ")([key, show(dictShow)(focus)]))(tail);
        };
      });
    };
  };
};

module.exports = {
  Show: Show,
  show: show,
  ShowRecordFields: ShowRecordFields,
  showRecordFields: showRecordFields,
  showBoolean: showBoolean,
  showInt: showInt,
  showNumber: showNumber,
  showChar: showChar,
  showString: showString,
  showArray: showArray,
  showRecord: showRecord,
  showRecordFieldsNil: showRecordFieldsNil,
  showRecordFieldsCons: showRecordFieldsCons
};
},{"./foreign.js":"../output/Data.Show/foreign.js","../Data.Symbol/index.js":"../output/Data.Symbol/index.js","../Record.Unsafe/index.js":"../output/Record.Unsafe/index.js","../Type.Data.RowList/index.js":"../output/Type.Data.RowList/index.js"}],"../output/Data.Unit/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Show = require("../Data.Show/index.js");

var showUnit = new Data_Show.Show(function (v) {
  return "unit";
});
module.exports = {
  showUnit: showUnit,
  unit: $foreign.unit
};
},{"./foreign.js":"../output/Data.Unit/foreign.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Functor/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Control_Semigroupoid = require("../Control.Semigroupoid/index.js");

var Data_Function = require("../Data.Function/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Functor = function Functor(map) {
  this.map = map;
};

var map = function map(dict) {
  return dict.map;
};

var mapFlipped = function mapFlipped(dictFunctor) {
  return function (fa) {
    return function (f) {
      return map(dictFunctor)(f)(fa);
    };
  };
};

var $$void = function $$void(dictFunctor) {
  return map(dictFunctor)(Data_Function["const"](Data_Unit.unit));
};

var voidLeft = function voidLeft(dictFunctor) {
  return function (f) {
    return function (x) {
      return map(dictFunctor)(Data_Function["const"](x))(f);
    };
  };
};

var voidRight = function voidRight(dictFunctor) {
  return function (x) {
    return map(dictFunctor)(Data_Function["const"](x));
  };
};

var functorFn = new Functor(Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn));
var functorArray = new Functor($foreign.arrayMap);

var flap = function flap(dictFunctor) {
  return function (ff) {
    return function (x) {
      return map(dictFunctor)(function (f) {
        return f(x);
      })(ff);
    };
  };
};

module.exports = {
  Functor: Functor,
  map: map,
  mapFlipped: mapFlipped,
  "void": $$void,
  voidRight: voidRight,
  voidLeft: voidLeft,
  flap: flap,
  functorFn: functorFn,
  functorArray: functorArray
};
},{"./foreign.js":"../output/Data.Functor/foreign.js","../Control.Semigroupoid/index.js":"../output/Control.Semigroupoid/index.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.Semigroup/foreign.js":[function(require,module,exports) {
"use strict";

exports.concatString = function (s1) {
  return function (s2) {
    return s1 + s2;
  };
};

exports.concatArray = function (xs) {
  return function (ys) {
    if (xs.length === 0) return ys;
    if (ys.length === 0) return xs;
    return xs.concat(ys);
  };
};
},{}],"../output/Data.Void/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_Show = require("../Data.Show/index.js");

var Void = function Void(x) {
  return x;
};

var absurd = function absurd(a) {
  var spin = function spin($copy_v) {
    var $tco_result;

    function $tco_loop(v) {
      $copy_v = v;
      return;
    }

    ;

    while (!false) {
      $tco_result = $tco_loop($copy_v);
    }

    ;
    return $tco_result;
  };

  return spin(a);
};

var showVoid = new Data_Show.Show(absurd);
module.exports = {
  absurd: absurd,
  showVoid: showVoid
};
},{"../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Semigroup/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Symbol = require("../Data.Symbol/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Data_Void = require("../Data.Void/index.js");

var Record_Unsafe = require("../Record.Unsafe/index.js");

var Type_Data_RowList = require("../Type.Data.RowList/index.js");

var SemigroupRecord = function SemigroupRecord(appendRecord) {
  this.appendRecord = appendRecord;
};

var Semigroup = function Semigroup(append) {
  this.append = append;
};

var semigroupVoid = new Semigroup(function (v) {
  return Data_Void.absurd;
});
var semigroupUnit = new Semigroup(function (v) {
  return function (v1) {
    return Data_Unit.unit;
  };
});
var semigroupString = new Semigroup($foreign.concatString);
var semigroupRecordNil = new SemigroupRecord(function (v) {
  return function (v1) {
    return function (v2) {
      return {};
    };
  };
});
var semigroupArray = new Semigroup($foreign.concatArray);

var appendRecord = function appendRecord(dict) {
  return dict.appendRecord;
};

var semigroupRecord = function semigroupRecord(dictRowToList) {
  return function (dictSemigroupRecord) {
    return new Semigroup(appendRecord(dictSemigroupRecord)(Type_Data_RowList.RLProxy.value));
  };
};

var append = function append(dict) {
  return dict.append;
};

var semigroupFn = function semigroupFn(dictSemigroup) {
  return new Semigroup(function (f) {
    return function (g) {
      return function (x) {
        return append(dictSemigroup)(f(x))(g(x));
      };
    };
  });
};

var semigroupRecordCons = function semigroupRecordCons(dictIsSymbol) {
  return function (dictCons) {
    return function (dictSemigroupRecord) {
      return function (dictSemigroup) {
        return new SemigroupRecord(function (v) {
          return function (ra) {
            return function (rb) {
              var tail = appendRecord(dictSemigroupRecord)(Type_Data_RowList.RLProxy.value)(ra)(rb);
              var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
              var insert = Record_Unsafe.unsafeSet(key);
              var get = Record_Unsafe.unsafeGet(key);
              return insert(append(dictSemigroup)(get(ra))(get(rb)))(tail);
            };
          };
        });
      };
    };
  };
};

module.exports = {
  Semigroup: Semigroup,
  append: append,
  SemigroupRecord: SemigroupRecord,
  appendRecord: appendRecord,
  semigroupString: semigroupString,
  semigroupUnit: semigroupUnit,
  semigroupVoid: semigroupVoid,
  semigroupFn: semigroupFn,
  semigroupArray: semigroupArray,
  semigroupRecord: semigroupRecord,
  semigroupRecordNil: semigroupRecordNil,
  semigroupRecordCons: semigroupRecordCons
};
},{"./foreign.js":"../output/Data.Semigroup/foreign.js","../Data.Symbol/index.js":"../output/Data.Symbol/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js","../Data.Void/index.js":"../output/Data.Void/index.js","../Record.Unsafe/index.js":"../output/Record.Unsafe/index.js","../Type.Data.RowList/index.js":"../output/Type.Data.RowList/index.js"}],"../output/Control.Alt/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_Functor = require("../Data.Functor/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Alt = function Alt(Functor0, alt) {
  this.Functor0 = Functor0;
  this.alt = alt;
};

var altArray = new Alt(function () {
  return Data_Functor.functorArray;
}, Data_Semigroup.append(Data_Semigroup.semigroupArray));

var alt = function alt(dict) {
  return dict.alt;
};

module.exports = {
  Alt: Alt,
  alt: alt,
  altArray: altArray
};
},{"../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js"}],"../output/Control.Apply/foreign.js":[function(require,module,exports) {
"use strict";

exports.arrayApply = function (fs) {
  return function (xs) {
    var l = fs.length;
    var k = xs.length;
    var result = new Array(l * k);
    var n = 0;

    for (var i = 0; i < l; i++) {
      var f = fs[i];

      for (var j = 0; j < k; j++) {
        result[n++] = f(xs[j]);
      }
    }

    return result;
  };
};
},{}],"../output/Control.Category/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Semigroupoid = require("../Control.Semigroupoid/index.js");

var Category = function Category(Semigroupoid0, identity) {
  this.Semigroupoid0 = Semigroupoid0;
  this.identity = identity;
};

var identity = function identity(dict) {
  return dict.identity;
};

var categoryFn = new Category(function () {
  return Control_Semigroupoid.semigroupoidFn;
}, function (x) {
  return x;
});
module.exports = {
  Category: Category,
  identity: identity,
  categoryFn: categoryFn
};
},{"../Control.Semigroupoid/index.js":"../output/Control.Semigroupoid/index.js"}],"../output/Control.Apply/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Control_Category = require("../Control.Category/index.js");

var Data_Function = require("../Data.Function/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Apply = function Apply(Functor0, apply) {
  this.Functor0 = Functor0;
  this.apply = apply;
};

var applyFn = new Apply(function () {
  return Data_Functor.functorFn;
}, function (f) {
  return function (g) {
    return function (x) {
      return f(x)(g(x));
    };
  };
});
var applyArray = new Apply(function () {
  return Data_Functor.functorArray;
}, $foreign.arrayApply);

var apply = function apply(dict) {
  return dict.apply;
};

var applyFirst = function applyFirst(dictApply) {
  return function (a) {
    return function (b) {
      return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Data_Function["const"])(a))(b);
    };
  };
};

var applySecond = function applySecond(dictApply) {
  return function (a) {
    return function (b) {
      return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Data_Function["const"](Control_Category.identity(Control_Category.categoryFn)))(a))(b);
    };
  };
};

var lift2 = function lift2(dictApply) {
  return function (f) {
    return function (a) {
      return function (b) {
        return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b);
      };
    };
  };
};

var lift3 = function lift3(dictApply) {
  return function (f) {
    return function (a) {
      return function (b) {
        return function (c) {
          return apply(dictApply)(apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b))(c);
        };
      };
    };
  };
};

var lift4 = function lift4(dictApply) {
  return function (f) {
    return function (a) {
      return function (b) {
        return function (c) {
          return function (d) {
            return apply(dictApply)(apply(dictApply)(apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b))(c))(d);
          };
        };
      };
    };
  };
};

var lift5 = function lift5(dictApply) {
  return function (f) {
    return function (a) {
      return function (b) {
        return function (c) {
          return function (d) {
            return function (e) {
              return apply(dictApply)(apply(dictApply)(apply(dictApply)(apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b))(c))(d))(e);
            };
          };
        };
      };
    };
  };
};

module.exports = {
  Apply: Apply,
  apply: apply,
  applyFirst: applyFirst,
  applySecond: applySecond,
  lift2: lift2,
  lift3: lift3,
  lift4: lift4,
  lift5: lift5,
  applyFn: applyFn,
  applyArray: applyArray
};
},{"./foreign.js":"../output/Control.Apply/foreign.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js"}],"../output/Control.Applicative/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Apply = require("../Control.Apply/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Applicative = function Applicative(Apply0, pure) {
  this.Apply0 = Apply0;
  this.pure = pure;
};

var pure = function pure(dict) {
  return dict.pure;
};

var unless = function unless(dictApplicative) {
  return function (v) {
    return function (v1) {
      if (!v) {
        return v1;
      }

      ;

      if (v) {
        return pure(dictApplicative)(Data_Unit.unit);
      }

      ;
      throw new Error("Failed pattern match at Control.Applicative (line 62, column 1 - line 62, column 65): " + [v.constructor.name, v1.constructor.name]);
    };
  };
};

var when = function when(dictApplicative) {
  return function (v) {
    return function (v1) {
      if (v) {
        return v1;
      }

      ;

      if (!v) {
        return pure(dictApplicative)(Data_Unit.unit);
      }

      ;
      throw new Error("Failed pattern match at Control.Applicative (line 57, column 1 - line 57, column 63): " + [v.constructor.name, v1.constructor.name]);
    };
  };
};

var liftA1 = function liftA1(dictApplicative) {
  return function (f) {
    return function (a) {
      return Control_Apply.apply(dictApplicative.Apply0())(pure(dictApplicative)(f))(a);
    };
  };
};

var applicativeFn = new Applicative(function () {
  return Control_Apply.applyFn;
}, function (x) {
  return function (v) {
    return x;
  };
});
var applicativeArray = new Applicative(function () {
  return Control_Apply.applyArray;
}, function (x) {
  return [x];
});
module.exports = {
  Applicative: Applicative,
  pure: pure,
  liftA1: liftA1,
  unless: unless,
  when: when,
  applicativeFn: applicativeFn,
  applicativeArray: applicativeArray
};
},{"../Control.Apply/index.js":"../output/Control.Apply/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Control.Bind/foreign.js":[function(require,module,exports) {
"use strict";

exports.arrayBind = function (arr) {
  return function (f) {
    var result = [];

    for (var i = 0, l = arr.length; i < l; i++) {
      Array.prototype.push.apply(result, f(arr[i]));
    }

    return result;
  };
};
},{}],"../output/Control.Bind/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Category = require("../Control.Category/index.js");

var Data_Function = require("../Data.Function/index.js");

var Discard = function Discard(discard) {
  this.discard = discard;
};

var Bind = function Bind(Apply0, bind) {
  this.Apply0 = Apply0;
  this.bind = bind;
};

var discard = function discard(dict) {
  return dict.discard;
};

var bindFn = new Bind(function () {
  return Control_Apply.applyFn;
}, function (m) {
  return function (f) {
    return function (x) {
      return f(m(x))(x);
    };
  };
});
var bindArray = new Bind(function () {
  return Control_Apply.applyArray;
}, $foreign.arrayBind);

var bind = function bind(dict) {
  return dict.bind;
};

var bindFlipped = function bindFlipped(dictBind) {
  return Data_Function.flip(bind(dictBind));
};

var composeKleisliFlipped = function composeKleisliFlipped(dictBind) {
  return function (f) {
    return function (g) {
      return function (a) {
        return bindFlipped(dictBind)(f)(g(a));
      };
    };
  };
};

var composeKleisli = function composeKleisli(dictBind) {
  return function (f) {
    return function (g) {
      return function (a) {
        return bind(dictBind)(f(a))(g);
      };
    };
  };
};

var discardUnit = new Discard(function (dictBind) {
  return bind(dictBind);
});

var ifM = function ifM(dictBind) {
  return function (cond) {
    return function (t) {
      return function (f) {
        return bind(dictBind)(cond)(function (cond$prime) {
          if (cond$prime) {
            return t;
          }

          ;
          return f;
        });
      };
    };
  };
};

var join = function join(dictBind) {
  return function (m) {
    return bind(dictBind)(m)(Control_Category.identity(Control_Category.categoryFn));
  };
};

module.exports = {
  Bind: Bind,
  bind: bind,
  bindFlipped: bindFlipped,
  Discard: Discard,
  discard: discard,
  join: join,
  composeKleisli: composeKleisli,
  composeKleisliFlipped: composeKleisliFlipped,
  ifM: ifM,
  bindFn: bindFn,
  bindArray: bindArray,
  discardUnit: discardUnit
};
},{"./foreign.js":"../output/Control.Bind/foreign.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Function/index.js":"../output/Data.Function/index.js"}],"../output/Control.Plus/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Alt = require("../Control.Alt/index.js");

var Plus = function Plus(Alt0, empty) {
  this.Alt0 = Alt0;
  this.empty = empty;
};

var plusArray = new Plus(function () {
  return Control_Alt.altArray;
}, []);

var empty = function empty(dict) {
  return dict.empty;
};

module.exports = {
  Plus: Plus,
  empty: empty,
  plusArray: plusArray
};
},{"../Control.Alt/index.js":"../output/Control.Alt/index.js"}],"../output/Data.Eq/foreign.js":[function(require,module,exports) {
"use strict";

var refEq = function refEq(r1) {
  return function (r2) {
    return r1 === r2;
  };
};

exports.eqBooleanImpl = refEq;
exports.eqIntImpl = refEq;
exports.eqNumberImpl = refEq;
exports.eqCharImpl = refEq;
exports.eqStringImpl = refEq;

exports.eqArrayImpl = function (f) {
  return function (xs) {
    return function (ys) {
      if (xs === ys) return true;
      if (xs.length !== ys.length) return false;

      for (var i = 0; i < xs.length; i++) {
        if (!f(xs[i])(ys[i])) return false;
      }

      return true;
    };
  };
};
},{}],"../output/Data.Eq/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Symbol = require("../Data.Symbol/index.js");

var Record_Unsafe = require("../Record.Unsafe/index.js");

var Type_Data_RowList = require("../Type.Data.RowList/index.js");

var EqRecord = function EqRecord(eqRecord) {
  this.eqRecord = eqRecord;
};

var Eq1 = function Eq1(eq1) {
  this.eq1 = eq1;
};

var Eq = function Eq(eq) {
  this.eq = eq;
};

var eqVoid = new Eq(function (v) {
  return function (v1) {
    return true;
  };
});
var eqUnit = new Eq(function (v) {
  return function (v1) {
    return true;
  };
});
var eqString = new Eq($foreign.eqStringImpl);
var eqRowNil = new EqRecord(function (v) {
  return function (v1) {
    return function (v2) {
      return true;
    };
  };
});

var eqRecord = function eqRecord(dict) {
  return dict.eqRecord;
};

var eqRec = function eqRec(dictRowToList) {
  return function (dictEqRecord) {
    return new Eq(eqRecord(dictEqRecord)(Type_Data_RowList.RLProxy.value));
  };
};

var eqNumber = new Eq($foreign.eqNumberImpl);
var eqInt = new Eq($foreign.eqIntImpl);
var eqChar = new Eq($foreign.eqCharImpl);
var eqBoolean = new Eq($foreign.eqBooleanImpl);

var eq1 = function eq1(dict) {
  return dict.eq1;
};

var eq = function eq(dict) {
  return dict.eq;
};

var eqArray = function eqArray(dictEq) {
  return new Eq($foreign.eqArrayImpl(eq(dictEq)));
};

var eq1Array = new Eq1(function (dictEq) {
  return eq(eqArray(dictEq));
});

var eqRowCons = function eqRowCons(dictEqRecord) {
  return function (dictCons) {
    return function (dictIsSymbol) {
      return function (dictEq) {
        return new EqRecord(function (v) {
          return function (ra) {
            return function (rb) {
              var tail = eqRecord(dictEqRecord)(Type_Data_RowList.RLProxy.value)(ra)(rb);
              var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
              var get = Record_Unsafe.unsafeGet(key);
              return eq(dictEq)(get(ra))(get(rb)) && tail;
            };
          };
        });
      };
    };
  };
};

var notEq = function notEq(dictEq) {
  return function (x) {
    return function (y) {
      return eq(eqBoolean)(eq(dictEq)(x)(y))(false);
    };
  };
};

var notEq1 = function notEq1(dictEq1) {
  return function (dictEq) {
    return function (x) {
      return function (y) {
        return eq(eqBoolean)(eq1(dictEq1)(dictEq)(x)(y))(false);
      };
    };
  };
};

module.exports = {
  Eq: Eq,
  eq: eq,
  notEq: notEq,
  Eq1: Eq1,
  eq1: eq1,
  notEq1: notEq1,
  EqRecord: EqRecord,
  eqRecord: eqRecord,
  eqBoolean: eqBoolean,
  eqInt: eqInt,
  eqNumber: eqNumber,
  eqChar: eqChar,
  eqString: eqString,
  eqUnit: eqUnit,
  eqVoid: eqVoid,
  eqArray: eqArray,
  eqRec: eqRec,
  eq1Array: eq1Array,
  eqRowNil: eqRowNil,
  eqRowCons: eqRowCons
};
},{"./foreign.js":"../output/Data.Eq/foreign.js","../Data.Symbol/index.js":"../output/Data.Symbol/index.js","../Record.Unsafe/index.js":"../output/Record.Unsafe/index.js","../Type.Data.RowList/index.js":"../output/Type.Data.RowList/index.js"}],"../output/Data.HeytingAlgebra/foreign.js":[function(require,module,exports) {
"use strict";

exports.boolConj = function (b1) {
  return function (b2) {
    return b1 && b2;
  };
};

exports.boolDisj = function (b1) {
  return function (b2) {
    return b1 || b2;
  };
};

exports.boolNot = function (b) {
  return !b;
};
},{}],"../output/Type.Data.Row/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var RProxy = function () {
  function RProxy() {}

  ;
  RProxy.value = new RProxy();
  return RProxy;
}();

module.exports = {
  RProxy: RProxy
};
},{}],"../output/Data.HeytingAlgebra/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Symbol = require("../Data.Symbol/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Record_Unsafe = require("../Record.Unsafe/index.js");

var Type_Data_Row = require("../Type.Data.Row/index.js");

var Type_Data_RowList = require("../Type.Data.RowList/index.js");

var HeytingAlgebraRecord = function HeytingAlgebraRecord(conjRecord, disjRecord, ffRecord, impliesRecord, notRecord, ttRecord) {
  this.conjRecord = conjRecord;
  this.disjRecord = disjRecord;
  this.ffRecord = ffRecord;
  this.impliesRecord = impliesRecord;
  this.notRecord = notRecord;
  this.ttRecord = ttRecord;
};

var HeytingAlgebra = function HeytingAlgebra(conj, disj, ff, implies, not, tt) {
  this.conj = conj;
  this.disj = disj;
  this.ff = ff;
  this.implies = implies;
  this.not = not;
  this.tt = tt;
};

var ttRecord = function ttRecord(dict) {
  return dict.ttRecord;
};

var tt = function tt(dict) {
  return dict.tt;
};

var notRecord = function notRecord(dict) {
  return dict.notRecord;
};

var not = function not(dict) {
  return dict.not;
};

var impliesRecord = function impliesRecord(dict) {
  return dict.impliesRecord;
};

var implies = function implies(dict) {
  return dict.implies;
};

var heytingAlgebraUnit = new HeytingAlgebra(function (v) {
  return function (v1) {
    return Data_Unit.unit;
  };
}, function (v) {
  return function (v1) {
    return Data_Unit.unit;
  };
}, Data_Unit.unit, function (v) {
  return function (v1) {
    return Data_Unit.unit;
  };
}, function (v) {
  return Data_Unit.unit;
}, Data_Unit.unit);
var heytingAlgebraRecordNil = new HeytingAlgebraRecord(function (v) {
  return function (v1) {
    return function (v2) {
      return {};
    };
  };
}, function (v) {
  return function (v1) {
    return function (v2) {
      return {};
    };
  };
}, function (v) {
  return function (v1) {
    return {};
  };
}, function (v) {
  return function (v1) {
    return function (v2) {
      return {};
    };
  };
}, function (v) {
  return function (v1) {
    return {};
  };
}, function (v) {
  return function (v1) {
    return {};
  };
});

var ffRecord = function ffRecord(dict) {
  return dict.ffRecord;
};

var ff = function ff(dict) {
  return dict.ff;
};

var disjRecord = function disjRecord(dict) {
  return dict.disjRecord;
};

var disj = function disj(dict) {
  return dict.disj;
};

var heytingAlgebraBoolean = new HeytingAlgebra($foreign.boolConj, $foreign.boolDisj, false, function (a) {
  return function (b) {
    return disj(heytingAlgebraBoolean)(not(heytingAlgebraBoolean)(a))(b);
  };
}, $foreign.boolNot, true);

var conjRecord = function conjRecord(dict) {
  return dict.conjRecord;
};

var heytingAlgebraRecord = function heytingAlgebraRecord(dictRowToList) {
  return function (dictHeytingAlgebraRecord) {
    return new HeytingAlgebra(conjRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value), disjRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value), ffRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value)(Type_Data_Row.RProxy.value), impliesRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value), notRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value), ttRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value)(Type_Data_Row.RProxy.value));
  };
};

var conj = function conj(dict) {
  return dict.conj;
};

var heytingAlgebraFunction = function heytingAlgebraFunction(dictHeytingAlgebra) {
  return new HeytingAlgebra(function (f) {
    return function (g) {
      return function (a) {
        return conj(dictHeytingAlgebra)(f(a))(g(a));
      };
    };
  }, function (f) {
    return function (g) {
      return function (a) {
        return disj(dictHeytingAlgebra)(f(a))(g(a));
      };
    };
  }, function (v) {
    return ff(dictHeytingAlgebra);
  }, function (f) {
    return function (g) {
      return function (a) {
        return implies(dictHeytingAlgebra)(f(a))(g(a));
      };
    };
  }, function (f) {
    return function (a) {
      return not(dictHeytingAlgebra)(f(a));
    };
  }, function (v) {
    return tt(dictHeytingAlgebra);
  });
};

var heytingAlgebraRecordCons = function heytingAlgebraRecordCons(dictIsSymbol) {
  return function (dictCons) {
    return function (dictHeytingAlgebraRecord) {
      return function (dictHeytingAlgebra) {
        return new HeytingAlgebraRecord(function (v) {
          return function (ra) {
            return function (rb) {
              var tail = conjRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value)(ra)(rb);
              var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
              var insert = Record_Unsafe.unsafeSet(key);
              var get = Record_Unsafe.unsafeGet(key);
              return insert(conj(dictHeytingAlgebra)(get(ra))(get(rb)))(tail);
            };
          };
        }, function (v) {
          return function (ra) {
            return function (rb) {
              var tail = disjRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value)(ra)(rb);
              var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
              var insert = Record_Unsafe.unsafeSet(key);
              var get = Record_Unsafe.unsafeGet(key);
              return insert(disj(dictHeytingAlgebra)(get(ra))(get(rb)))(tail);
            };
          };
        }, function (v) {
          return function (row) {
            var tail = ffRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value)(row);
            var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
            var insert = Record_Unsafe.unsafeSet(key);
            return insert(ff(dictHeytingAlgebra))(tail);
          };
        }, function (v) {
          return function (ra) {
            return function (rb) {
              var tail = impliesRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value)(ra)(rb);
              var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
              var insert = Record_Unsafe.unsafeSet(key);
              var get = Record_Unsafe.unsafeGet(key);
              return insert(implies(dictHeytingAlgebra)(get(ra))(get(rb)))(tail);
            };
          };
        }, function (v) {
          return function (row) {
            var tail = notRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value)(row);
            var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
            var insert = Record_Unsafe.unsafeSet(key);
            var get = Record_Unsafe.unsafeGet(key);
            return insert(not(dictHeytingAlgebra)(get(row)))(tail);
          };
        }, function (v) {
          return function (row) {
            var tail = ttRecord(dictHeytingAlgebraRecord)(Type_Data_RowList.RLProxy.value)(row);
            var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
            var insert = Record_Unsafe.unsafeSet(key);
            return insert(tt(dictHeytingAlgebra))(tail);
          };
        });
      };
    };
  };
};

module.exports = {
  HeytingAlgebra: HeytingAlgebra,
  tt: tt,
  ff: ff,
  implies: implies,
  conj: conj,
  disj: disj,
  not: not,
  HeytingAlgebraRecord: HeytingAlgebraRecord,
  ffRecord: ffRecord,
  ttRecord: ttRecord,
  impliesRecord: impliesRecord,
  conjRecord: conjRecord,
  disjRecord: disjRecord,
  notRecord: notRecord,
  heytingAlgebraBoolean: heytingAlgebraBoolean,
  heytingAlgebraUnit: heytingAlgebraUnit,
  heytingAlgebraFunction: heytingAlgebraFunction,
  heytingAlgebraRecord: heytingAlgebraRecord,
  heytingAlgebraRecordNil: heytingAlgebraRecordNil,
  heytingAlgebraRecordCons: heytingAlgebraRecordCons
};
},{"./foreign.js":"../output/Data.HeytingAlgebra/foreign.js","../Data.Symbol/index.js":"../output/Data.Symbol/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js","../Record.Unsafe/index.js":"../output/Record.Unsafe/index.js","../Type.Data.Row/index.js":"../output/Type.Data.Row/index.js","../Type.Data.RowList/index.js":"../output/Type.Data.RowList/index.js"}],"../output/Control.Alternative/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Plus = require("../Control.Plus/index.js");

var Alternative = function Alternative(Applicative0, Plus1) {
  this.Applicative0 = Applicative0;
  this.Plus1 = Plus1;
};

var alternativeArray = new Alternative(function () {
  return Control_Applicative.applicativeArray;
}, function () {
  return Control_Plus.plusArray;
});
module.exports = {
  Alternative: Alternative,
  alternativeArray: alternativeArray
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Plus/index.js":"../output/Control.Plus/index.js"}],"../output/Control.Extend/foreign.js":[function(require,module,exports) {
"use strict";

exports.arrayExtend = function (f) {
  return function (xs) {
    return xs.map(function (_, i, xs) {
      return f(xs.slice(i));
    });
  };
};
},{}],"../output/Control.Extend/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Control_Category = require("../Control.Category/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Extend = function Extend(Functor0, extend) {
  this.Functor0 = Functor0;
  this.extend = extend;
};

var extendFn = function extendFn(dictSemigroup) {
  return new Extend(function () {
    return Data_Functor.functorFn;
  }, function (f) {
    return function (g) {
      return function (w) {
        return f(function (w$prime) {
          return g(Data_Semigroup.append(dictSemigroup)(w)(w$prime));
        });
      };
    };
  });
};

var extendArray = new Extend(function () {
  return Data_Functor.functorArray;
}, $foreign.arrayExtend);

var extend = function extend(dict) {
  return dict.extend;
};

var extendFlipped = function extendFlipped(dictExtend) {
  return function (w) {
    return function (f) {
      return extend(dictExtend)(f)(w);
    };
  };
};

var duplicate = function duplicate(dictExtend) {
  return extend(dictExtend)(Control_Category.identity(Control_Category.categoryFn));
};

var composeCoKleisliFlipped = function composeCoKleisliFlipped(dictExtend) {
  return function (f) {
    return function (g) {
      return function (w) {
        return f(extend(dictExtend)(g)(w));
      };
    };
  };
};

var composeCoKleisli = function composeCoKleisli(dictExtend) {
  return function (f) {
    return function (g) {
      return function (w) {
        return g(extend(dictExtend)(f)(w));
      };
    };
  };
};

module.exports = {
  Extend: Extend,
  extend: extend,
  extendFlipped: extendFlipped,
  composeCoKleisli: composeCoKleisli,
  composeCoKleisliFlipped: composeCoKleisliFlipped,
  duplicate: duplicate,
  extendFn: extendFn,
  extendArray: extendArray
};
},{"./foreign.js":"../output/Control.Extend/foreign.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js"}],"../output/Control.Monad/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Monad = function Monad(Applicative0, Bind1) {
  this.Applicative0 = Applicative0;
  this.Bind1 = Bind1;
};

var whenM = function whenM(dictMonad) {
  return function (mb) {
    return function (m) {
      return Control_Bind.bind(dictMonad.Bind1())(mb)(function (b) {
        return Control_Applicative.when(dictMonad.Applicative0())(b)(m);
      });
    };
  };
};

var unlessM = function unlessM(dictMonad) {
  return function (mb) {
    return function (m) {
      return Control_Bind.bind(dictMonad.Bind1())(mb)(function (b) {
        return Control_Applicative.unless(dictMonad.Applicative0())(b)(m);
      });
    };
  };
};

var monadFn = new Monad(function () {
  return Control_Applicative.applicativeFn;
}, function () {
  return Control_Bind.bindFn;
});
var monadArray = new Monad(function () {
  return Control_Applicative.applicativeArray;
}, function () {
  return Control_Bind.bindArray;
});

var liftM1 = function liftM1(dictMonad) {
  return function (f) {
    return function (a) {
      return Control_Bind.bind(dictMonad.Bind1())(a)(function (a$prime) {
        return Control_Applicative.pure(dictMonad.Applicative0())(f(a$prime));
      });
    };
  };
};

var ap = function ap(dictMonad) {
  return function (f) {
    return function (a) {
      return Control_Bind.bind(dictMonad.Bind1())(f)(function (f$prime) {
        return Control_Bind.bind(dictMonad.Bind1())(a)(function (a$prime) {
          return Control_Applicative.pure(dictMonad.Applicative0())(f$prime(a$prime));
        });
      });
    };
  };
};

module.exports = {
  Monad: Monad,
  liftM1: liftM1,
  ap: ap,
  whenM: whenM,
  unlessM: unlessM,
  monadFn: monadFn,
  monadArray: monadArray
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js"}],"../output/Control.MonadZero/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Alternative = require("../Control.Alternative/index.js");

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Control_Plus = require("../Control.Plus/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var MonadZero = function MonadZero(Alternative1, Monad0) {
  this.Alternative1 = Alternative1;
  this.Monad0 = Monad0;
};

var monadZeroArray = new MonadZero(function () {
  return Control_Alternative.alternativeArray;
}, function () {
  return Control_Monad.monadArray;
});

var guard = function guard(dictMonadZero) {
  return function (v) {
    if (v) {
      return Control_Applicative.pure(dictMonadZero.Alternative1().Applicative0())(Data_Unit.unit);
    }

    ;

    if (!v) {
      return Control_Plus.empty(dictMonadZero.Alternative1().Plus1());
    }

    ;
    throw new Error("Failed pattern match at Control.MonadZero (line 54, column 1 - line 54, column 52): " + [v.constructor.name]);
  };
};

module.exports = {
  MonadZero: MonadZero,
  guard: guard,
  monadZeroArray: monadZeroArray
};
},{"../Control.Alternative/index.js":"../output/Control.Alternative/index.js","../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Control.Plus/index.js":"../output/Control.Plus/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.Bounded/foreign.js":[function(require,module,exports) {
"use strict";

exports.topInt = 2147483647;
exports.bottomInt = -2147483648;
exports.topChar = String.fromCharCode(65535);
exports.bottomChar = String.fromCharCode(0);
exports.topNumber = Number.POSITIVE_INFINITY;
exports.bottomNumber = Number.NEGATIVE_INFINITY;
},{}],"../output/Data.Ord/foreign.js":[function(require,module,exports) {
"use strict";

var unsafeCompareImpl = function unsafeCompareImpl(lt) {
  return function (eq) {
    return function (gt) {
      return function (x) {
        return function (y) {
          return x < y ? lt : x === y ? eq : gt;
        };
      };
    };
  };
};

exports.ordBooleanImpl = unsafeCompareImpl;
exports.ordIntImpl = unsafeCompareImpl;
exports.ordNumberImpl = unsafeCompareImpl;
exports.ordStringImpl = unsafeCompareImpl;
exports.ordCharImpl = unsafeCompareImpl;

exports.ordArrayImpl = function (f) {
  return function (xs) {
    return function (ys) {
      var i = 0;
      var xlen = xs.length;
      var ylen = ys.length;

      while (i < xlen && i < ylen) {
        var x = xs[i];
        var y = ys[i];
        var o = f(x)(y);

        if (o !== 0) {
          return o;
        }

        i++;
      }

      if (xlen === ylen) {
        return 0;
      } else if (xlen > ylen) {
        return -1;
      } else {
        return 1;
      }
    };
  };
};
},{}],"../output/Data.Ordering/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_Eq = require("../Data.Eq/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Show = require("../Data.Show/index.js");

var LT = function () {
  function LT() {}

  ;
  LT.value = new LT();
  return LT;
}();

var GT = function () {
  function GT() {}

  ;
  GT.value = new GT();
  return GT;
}();

var EQ = function () {
  function EQ() {}

  ;
  EQ.value = new EQ();
  return EQ;
}();

var showOrdering = new Data_Show.Show(function (v) {
  if (v instanceof LT) {
    return "LT";
  }

  ;

  if (v instanceof GT) {
    return "GT";
  }

  ;

  if (v instanceof EQ) {
    return "EQ";
  }

  ;
  throw new Error("Failed pattern match at Data.Ordering (line 26, column 1 - line 29, column 17): " + [v.constructor.name]);
});
var semigroupOrdering = new Data_Semigroup.Semigroup(function (v) {
  return function (v1) {
    if (v instanceof LT) {
      return LT.value;
    }

    ;

    if (v instanceof GT) {
      return GT.value;
    }

    ;

    if (v instanceof EQ) {
      return v1;
    }

    ;
    throw new Error("Failed pattern match at Data.Ordering (line 21, column 1 - line 24, column 18): " + [v.constructor.name, v1.constructor.name]);
  };
});

var invert = function invert(v) {
  if (v instanceof GT) {
    return LT.value;
  }

  ;

  if (v instanceof EQ) {
    return EQ.value;
  }

  ;

  if (v instanceof LT) {
    return GT.value;
  }

  ;
  throw new Error("Failed pattern match at Data.Ordering (line 33, column 1 - line 33, column 31): " + [v.constructor.name]);
};

var eqOrdering = new Data_Eq.Eq(function (v) {
  return function (v1) {
    if (v instanceof LT && v1 instanceof LT) {
      return true;
    }

    ;

    if (v instanceof GT && v1 instanceof GT) {
      return true;
    }

    ;

    if (v instanceof EQ && v1 instanceof EQ) {
      return true;
    }

    ;
    return false;
  };
});
module.exports = {
  LT: LT,
  GT: GT,
  EQ: EQ,
  invert: invert,
  eqOrdering: eqOrdering,
  semigroupOrdering: semigroupOrdering,
  showOrdering: showOrdering
};
},{"../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Ring/foreign.js":[function(require,module,exports) {
"use strict";

exports.intSub = function (x) {
  return function (y) {
    /* jshint bitwise: false */
    return x - y | 0;
  };
};

exports.numSub = function (n1) {
  return function (n2) {
    return n1 - n2;
  };
};
},{}],"../output/Data.Semiring/foreign.js":[function(require,module,exports) {
"use strict";

exports.intAdd = function (x) {
  return function (y) {
    /* jshint bitwise: false */
    return x + y | 0;
  };
};

exports.intMul = function (x) {
  return function (y) {
    /* jshint bitwise: false */
    return x * y | 0;
  };
};

exports.numAdd = function (n1) {
  return function (n2) {
    return n1 + n2;
  };
};

exports.numMul = function (n1) {
  return function (n2) {
    return n1 * n2;
  };
};
},{}],"../output/Data.Semiring/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Symbol = require("../Data.Symbol/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Record_Unsafe = require("../Record.Unsafe/index.js");

var Type_Data_Row = require("../Type.Data.Row/index.js");

var Type_Data_RowList = require("../Type.Data.RowList/index.js");

var SemiringRecord = function SemiringRecord(addRecord, mulRecord, oneRecord, zeroRecord) {
  this.addRecord = addRecord;
  this.mulRecord = mulRecord;
  this.oneRecord = oneRecord;
  this.zeroRecord = zeroRecord;
};

var Semiring = function Semiring(add, mul, one, zero) {
  this.add = add;
  this.mul = mul;
  this.one = one;
  this.zero = zero;
};

var zeroRecord = function zeroRecord(dict) {
  return dict.zeroRecord;
};

var zero = function zero(dict) {
  return dict.zero;
};

var semiringUnit = new Semiring(function (v) {
  return function (v1) {
    return Data_Unit.unit;
  };
}, function (v) {
  return function (v1) {
    return Data_Unit.unit;
  };
}, Data_Unit.unit, Data_Unit.unit);
var semiringRecordNil = new SemiringRecord(function (v) {
  return function (v1) {
    return function (v2) {
      return {};
    };
  };
}, function (v) {
  return function (v1) {
    return function (v2) {
      return {};
    };
  };
}, function (v) {
  return function (v1) {
    return {};
  };
}, function (v) {
  return function (v1) {
    return {};
  };
});
var semiringNumber = new Semiring($foreign.numAdd, $foreign.numMul, 1.0, 0.0);
var semiringInt = new Semiring($foreign.intAdd, $foreign.intMul, 1, 0);

var oneRecord = function oneRecord(dict) {
  return dict.oneRecord;
};

var one = function one(dict) {
  return dict.one;
};

var mulRecord = function mulRecord(dict) {
  return dict.mulRecord;
};

var mul = function mul(dict) {
  return dict.mul;
};

var addRecord = function addRecord(dict) {
  return dict.addRecord;
};

var semiringRecord = function semiringRecord(dictRowToList) {
  return function (dictSemiringRecord) {
    return new Semiring(addRecord(dictSemiringRecord)(Type_Data_RowList.RLProxy.value), mulRecord(dictSemiringRecord)(Type_Data_RowList.RLProxy.value), oneRecord(dictSemiringRecord)(Type_Data_RowList.RLProxy.value)(Type_Data_Row.RProxy.value), zeroRecord(dictSemiringRecord)(Type_Data_RowList.RLProxy.value)(Type_Data_Row.RProxy.value));
  };
};

var add = function add(dict) {
  return dict.add;
};

var semiringFn = function semiringFn(dictSemiring) {
  return new Semiring(function (f) {
    return function (g) {
      return function (x) {
        return add(dictSemiring)(f(x))(g(x));
      };
    };
  }, function (f) {
    return function (g) {
      return function (x) {
        return mul(dictSemiring)(f(x))(g(x));
      };
    };
  }, function (v) {
    return one(dictSemiring);
  }, function (v) {
    return zero(dictSemiring);
  });
};

var semiringRecordCons = function semiringRecordCons(dictIsSymbol) {
  return function (dictCons) {
    return function (dictSemiringRecord) {
      return function (dictSemiring) {
        return new SemiringRecord(function (v) {
          return function (ra) {
            return function (rb) {
              var tail = addRecord(dictSemiringRecord)(Type_Data_RowList.RLProxy.value)(ra)(rb);
              var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
              var insert = Record_Unsafe.unsafeSet(key);
              var get = Record_Unsafe.unsafeGet(key);
              return insert(add(dictSemiring)(get(ra))(get(rb)))(tail);
            };
          };
        }, function (v) {
          return function (ra) {
            return function (rb) {
              var tail = mulRecord(dictSemiringRecord)(Type_Data_RowList.RLProxy.value)(ra)(rb);
              var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
              var insert = Record_Unsafe.unsafeSet(key);
              var get = Record_Unsafe.unsafeGet(key);
              return insert(mul(dictSemiring)(get(ra))(get(rb)))(tail);
            };
          };
        }, function (v) {
          return function (v1) {
            var tail = oneRecord(dictSemiringRecord)(Type_Data_RowList.RLProxy.value)(Type_Data_Row.RProxy.value);
            var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
            var insert = Record_Unsafe.unsafeSet(key);
            return insert(one(dictSemiring))(tail);
          };
        }, function (v) {
          return function (v1) {
            var tail = zeroRecord(dictSemiringRecord)(Type_Data_RowList.RLProxy.value)(Type_Data_Row.RProxy.value);
            var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
            var insert = Record_Unsafe.unsafeSet(key);
            return insert(zero(dictSemiring))(tail);
          };
        });
      };
    };
  };
};

module.exports = {
  Semiring: Semiring,
  add: add,
  zero: zero,
  mul: mul,
  one: one,
  SemiringRecord: SemiringRecord,
  addRecord: addRecord,
  mulRecord: mulRecord,
  oneRecord: oneRecord,
  zeroRecord: zeroRecord,
  semiringInt: semiringInt,
  semiringNumber: semiringNumber,
  semiringFn: semiringFn,
  semiringUnit: semiringUnit,
  semiringRecord: semiringRecord,
  semiringRecordNil: semiringRecordNil,
  semiringRecordCons: semiringRecordCons
};
},{"./foreign.js":"../output/Data.Semiring/foreign.js","../Data.Symbol/index.js":"../output/Data.Symbol/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js","../Record.Unsafe/index.js":"../output/Record.Unsafe/index.js","../Type.Data.Row/index.js":"../output/Type.Data.Row/index.js","../Type.Data.RowList/index.js":"../output/Type.Data.RowList/index.js"}],"../output/Data.Ring/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Semiring = require("../Data.Semiring/index.js");

var Data_Symbol = require("../Data.Symbol/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Record_Unsafe = require("../Record.Unsafe/index.js");

var Type_Data_RowList = require("../Type.Data.RowList/index.js");

var RingRecord = function RingRecord(SemiringRecord0, subRecord) {
  this.SemiringRecord0 = SemiringRecord0;
  this.subRecord = subRecord;
};

var Ring = function Ring(Semiring0, sub) {
  this.Semiring0 = Semiring0;
  this.sub = sub;
};

var subRecord = function subRecord(dict) {
  return dict.subRecord;
};

var sub = function sub(dict) {
  return dict.sub;
};

var ringUnit = new Ring(function () {
  return Data_Semiring.semiringUnit;
}, function (v) {
  return function (v1) {
    return Data_Unit.unit;
  };
});
var ringRecordNil = new RingRecord(function () {
  return Data_Semiring.semiringRecordNil;
}, function (v) {
  return function (v1) {
    return function (v2) {
      return {};
    };
  };
});

var ringRecordCons = function ringRecordCons(dictIsSymbol) {
  return function (dictCons) {
    return function (dictRingRecord) {
      return function (dictRing) {
        return new RingRecord(function () {
          return Data_Semiring.semiringRecordCons(dictIsSymbol)()(dictRingRecord.SemiringRecord0())(dictRing.Semiring0());
        }, function (v) {
          return function (ra) {
            return function (rb) {
              var tail = subRecord(dictRingRecord)(Type_Data_RowList.RLProxy.value)(ra)(rb);
              var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
              var insert = Record_Unsafe.unsafeSet(key);
              var get = Record_Unsafe.unsafeGet(key);
              return insert(sub(dictRing)(get(ra))(get(rb)))(tail);
            };
          };
        });
      };
    };
  };
};

var ringRecord = function ringRecord(dictRowToList) {
  return function (dictRingRecord) {
    return new Ring(function () {
      return Data_Semiring.semiringRecord()(dictRingRecord.SemiringRecord0());
    }, subRecord(dictRingRecord)(Type_Data_RowList.RLProxy.value));
  };
};

var ringNumber = new Ring(function () {
  return Data_Semiring.semiringNumber;
}, $foreign.numSub);
var ringInt = new Ring(function () {
  return Data_Semiring.semiringInt;
}, $foreign.intSub);

var ringFn = function ringFn(dictRing) {
  return new Ring(function () {
    return Data_Semiring.semiringFn(dictRing.Semiring0());
  }, function (f) {
    return function (g) {
      return function (x) {
        return sub(dictRing)(f(x))(g(x));
      };
    };
  });
};

var negate = function negate(dictRing) {
  return function (a) {
    return sub(dictRing)(Data_Semiring.zero(dictRing.Semiring0()))(a);
  };
};

module.exports = {
  Ring: Ring,
  sub: sub,
  negate: negate,
  RingRecord: RingRecord,
  subRecord: subRecord,
  ringInt: ringInt,
  ringNumber: ringNumber,
  ringUnit: ringUnit,
  ringFn: ringFn,
  ringRecord: ringRecord,
  ringRecordNil: ringRecordNil,
  ringRecordCons: ringRecordCons
};
},{"./foreign.js":"../output/Data.Ring/foreign.js","../Data.Semiring/index.js":"../output/Data.Semiring/index.js","../Data.Symbol/index.js":"../output/Data.Symbol/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js","../Record.Unsafe/index.js":"../output/Record.Unsafe/index.js","../Type.Data.RowList/index.js":"../output/Type.Data.RowList/index.js"}],"../output/Data.Ord/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Ordering = require("../Data.Ordering/index.js");

var Data_Ring = require("../Data.Ring/index.js");

var Data_Semiring = require("../Data.Semiring/index.js");

var Data_Symbol = require("../Data.Symbol/index.js");

var Record_Unsafe = require("../Record.Unsafe/index.js");

var Type_Data_RowList = require("../Type.Data.RowList/index.js");

var OrdRecord = function OrdRecord(EqRecord0, compareRecord) {
  this.EqRecord0 = EqRecord0;
  this.compareRecord = compareRecord;
};

var Ord1 = function Ord1(Eq10, compare1) {
  this.Eq10 = Eq10;
  this.compare1 = compare1;
};

var Ord = function Ord(Eq0, compare) {
  this.Eq0 = Eq0;
  this.compare = compare;
};

var ordVoid = new Ord(function () {
  return Data_Eq.eqVoid;
}, function (v) {
  return function (v1) {
    return Data_Ordering.EQ.value;
  };
});
var ordUnit = new Ord(function () {
  return Data_Eq.eqUnit;
}, function (v) {
  return function (v1) {
    return Data_Ordering.EQ.value;
  };
});
var ordString = new Ord(function () {
  return Data_Eq.eqString;
}, $foreign.ordStringImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value));
var ordRecordNil = new OrdRecord(function () {
  return Data_Eq.eqRowNil;
}, function (v) {
  return function (v1) {
    return function (v2) {
      return Data_Ordering.EQ.value;
    };
  };
});
var ordOrdering = new Ord(function () {
  return Data_Ordering.eqOrdering;
}, function (v) {
  return function (v1) {
    if (v instanceof Data_Ordering.LT && v1 instanceof Data_Ordering.LT) {
      return Data_Ordering.EQ.value;
    }

    ;

    if (v instanceof Data_Ordering.EQ && v1 instanceof Data_Ordering.EQ) {
      return Data_Ordering.EQ.value;
    }

    ;

    if (v instanceof Data_Ordering.GT && v1 instanceof Data_Ordering.GT) {
      return Data_Ordering.EQ.value;
    }

    ;

    if (v instanceof Data_Ordering.LT) {
      return Data_Ordering.LT.value;
    }

    ;

    if (v instanceof Data_Ordering.EQ && v1 instanceof Data_Ordering.LT) {
      return Data_Ordering.GT.value;
    }

    ;

    if (v instanceof Data_Ordering.EQ && v1 instanceof Data_Ordering.GT) {
      return Data_Ordering.LT.value;
    }

    ;

    if (v instanceof Data_Ordering.GT) {
      return Data_Ordering.GT.value;
    }

    ;
    throw new Error("Failed pattern match at Data.Ord (line 112, column 1 - line 119, column 21): " + [v.constructor.name, v1.constructor.name]);
  };
});
var ordNumber = new Ord(function () {
  return Data_Eq.eqNumber;
}, $foreign.ordNumberImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value));
var ordInt = new Ord(function () {
  return Data_Eq.eqInt;
}, $foreign.ordIntImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value));
var ordChar = new Ord(function () {
  return Data_Eq.eqChar;
}, $foreign.ordCharImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value));
var ordBoolean = new Ord(function () {
  return Data_Eq.eqBoolean;
}, $foreign.ordBooleanImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value));

var compareRecord = function compareRecord(dict) {
  return dict.compareRecord;
};

var ordRecord = function ordRecord(dictRowToList) {
  return function (dictOrdRecord) {
    return new Ord(function () {
      return Data_Eq.eqRec()(dictOrdRecord.EqRecord0());
    }, compareRecord(dictOrdRecord)(Type_Data_RowList.RLProxy.value));
  };
};

var compare1 = function compare1(dict) {
  return dict.compare1;
};

var compare = function compare(dict) {
  return dict.compare;
};

var comparing = function comparing(dictOrd) {
  return function (f) {
    return function (x) {
      return function (y) {
        return compare(dictOrd)(f(x))(f(y));
      };
    };
  };
};

var greaterThan = function greaterThan(dictOrd) {
  return function (a1) {
    return function (a2) {
      var v = compare(dictOrd)(a1)(a2);

      if (v instanceof Data_Ordering.GT) {
        return true;
      }

      ;
      return false;
    };
  };
};

var greaterThanOrEq = function greaterThanOrEq(dictOrd) {
  return function (a1) {
    return function (a2) {
      var v = compare(dictOrd)(a1)(a2);

      if (v instanceof Data_Ordering.LT) {
        return false;
      }

      ;
      return true;
    };
  };
};

var signum = function signum(dictOrd) {
  return function (dictRing) {
    return function (x) {
      var $43 = greaterThanOrEq(dictOrd)(x)(Data_Semiring.zero(dictRing.Semiring0()));

      if ($43) {
        return Data_Semiring.one(dictRing.Semiring0());
      }

      ;
      return Data_Ring.negate(dictRing)(Data_Semiring.one(dictRing.Semiring0()));
    };
  };
};

var lessThan = function lessThan(dictOrd) {
  return function (a1) {
    return function (a2) {
      var v = compare(dictOrd)(a1)(a2);

      if (v instanceof Data_Ordering.LT) {
        return true;
      }

      ;
      return false;
    };
  };
};

var lessThanOrEq = function lessThanOrEq(dictOrd) {
  return function (a1) {
    return function (a2) {
      var v = compare(dictOrd)(a1)(a2);

      if (v instanceof Data_Ordering.GT) {
        return false;
      }

      ;
      return true;
    };
  };
};

var max = function max(dictOrd) {
  return function (x) {
    return function (y) {
      var v = compare(dictOrd)(x)(y);

      if (v instanceof Data_Ordering.LT) {
        return y;
      }

      ;

      if (v instanceof Data_Ordering.EQ) {
        return x;
      }

      ;

      if (v instanceof Data_Ordering.GT) {
        return x;
      }

      ;
      throw new Error("Failed pattern match at Data.Ord (line 167, column 3 - line 170, column 12): " + [v.constructor.name]);
    };
  };
};

var min = function min(dictOrd) {
  return function (x) {
    return function (y) {
      var v = compare(dictOrd)(x)(y);

      if (v instanceof Data_Ordering.LT) {
        return x;
      }

      ;

      if (v instanceof Data_Ordering.EQ) {
        return x;
      }

      ;

      if (v instanceof Data_Ordering.GT) {
        return y;
      }

      ;
      throw new Error("Failed pattern match at Data.Ord (line 158, column 3 - line 161, column 12): " + [v.constructor.name]);
    };
  };
};

var ordArray = function ordArray(dictOrd) {
  return new Ord(function () {
    return Data_Eq.eqArray(dictOrd.Eq0());
  }, function () {
    var toDelta = function toDelta(x) {
      return function (y) {
        var v = compare(dictOrd)(x)(y);

        if (v instanceof Data_Ordering.EQ) {
          return 0;
        }

        ;

        if (v instanceof Data_Ordering.LT) {
          return 1;
        }

        ;

        if (v instanceof Data_Ordering.GT) {
          return -1 | 0;
        }

        ;
        throw new Error("Failed pattern match at Data.Ord (line 65, column 7 - line 68, column 17): " + [v.constructor.name]);
      };
    };

    return function (xs) {
      return function (ys) {
        return compare(ordInt)(0)($foreign.ordArrayImpl(toDelta)(xs)(ys));
      };
    };
  }());
};

var ord1Array = new Ord1(function () {
  return Data_Eq.eq1Array;
}, function (dictOrd) {
  return compare(ordArray(dictOrd));
});

var ordRecordCons = function ordRecordCons(dictOrdRecord) {
  return function (dictCons) {
    return function (dictIsSymbol) {
      return function (dictOrd) {
        return new OrdRecord(function () {
          return Data_Eq.eqRowCons(dictOrdRecord.EqRecord0())()(dictIsSymbol)(dictOrd.Eq0());
        }, function (v) {
          return function (ra) {
            return function (rb) {
              var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
              var left = compare(dictOrd)(Record_Unsafe.unsafeGet(key)(ra))(Record_Unsafe.unsafeGet(key)(rb));
              var $49 = Data_Eq.notEq(Data_Ordering.eqOrdering)(left)(Data_Ordering.EQ.value);

              if ($49) {
                return left;
              }

              ;
              return compareRecord(dictOrdRecord)(Type_Data_RowList.RLProxy.value)(ra)(rb);
            };
          };
        });
      };
    };
  };
};

var clamp = function clamp(dictOrd) {
  return function (low) {
    return function (hi) {
      return function (x) {
        return min(dictOrd)(hi)(max(dictOrd)(low)(x));
      };
    };
  };
};

var between = function between(dictOrd) {
  return function (low) {
    return function (hi) {
      return function (x) {
        if (lessThan(dictOrd)(x)(low)) {
          return false;
        }

        ;

        if (greaterThan(dictOrd)(x)(hi)) {
          return false;
        }

        ;
        return true;
      };
    };
  };
};

var abs = function abs(dictOrd) {
  return function (dictRing) {
    return function (x) {
      var $53 = greaterThanOrEq(dictOrd)(x)(Data_Semiring.zero(dictRing.Semiring0()));

      if ($53) {
        return x;
      }

      ;
      return Data_Ring.negate(dictRing)(x);
    };
  };
};

module.exports = {
  Ord: Ord,
  compare: compare,
  Ord1: Ord1,
  compare1: compare1,
  lessThan: lessThan,
  lessThanOrEq: lessThanOrEq,
  greaterThan: greaterThan,
  greaterThanOrEq: greaterThanOrEq,
  comparing: comparing,
  min: min,
  max: max,
  clamp: clamp,
  between: between,
  abs: abs,
  signum: signum,
  OrdRecord: OrdRecord,
  compareRecord: compareRecord,
  ordBoolean: ordBoolean,
  ordInt: ordInt,
  ordNumber: ordNumber,
  ordString: ordString,
  ordChar: ordChar,
  ordUnit: ordUnit,
  ordVoid: ordVoid,
  ordArray: ordArray,
  ordOrdering: ordOrdering,
  ord1Array: ord1Array,
  ordRecordNil: ordRecordNil,
  ordRecordCons: ordRecordCons,
  ordRecord: ordRecord
};
},{"./foreign.js":"../output/Data.Ord/foreign.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Ordering/index.js":"../output/Data.Ordering/index.js","../Data.Ring/index.js":"../output/Data.Ring/index.js","../Data.Semiring/index.js":"../output/Data.Semiring/index.js","../Data.Symbol/index.js":"../output/Data.Symbol/index.js","../Record.Unsafe/index.js":"../output/Record.Unsafe/index.js","../Type.Data.RowList/index.js":"../output/Type.Data.RowList/index.js"}],"../output/Data.Bounded/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Ordering = require("../Data.Ordering/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Bounded = function Bounded(Ord0, bottom, top) {
  this.Ord0 = Ord0;
  this.bottom = bottom;
  this.top = top;
};

var top = function top(dict) {
  return dict.top;
};

var boundedUnit = new Bounded(function () {
  return Data_Ord.ordUnit;
}, Data_Unit.unit, Data_Unit.unit);
var boundedOrdering = new Bounded(function () {
  return Data_Ord.ordOrdering;
}, Data_Ordering.LT.value, Data_Ordering.GT.value);
var boundedNumber = new Bounded(function () {
  return Data_Ord.ordNumber;
}, $foreign.bottomNumber, $foreign.topNumber);
var boundedInt = new Bounded(function () {
  return Data_Ord.ordInt;
}, $foreign.bottomInt, $foreign.topInt);
var boundedChar = new Bounded(function () {
  return Data_Ord.ordChar;
}, $foreign.bottomChar, $foreign.topChar);
var boundedBoolean = new Bounded(function () {
  return Data_Ord.ordBoolean;
}, false, true);

var bottom = function bottom(dict) {
  return dict.bottom;
};

module.exports = {
  Bounded: Bounded,
  bottom: bottom,
  top: top,
  boundedBoolean: boundedBoolean,
  boundedInt: boundedInt,
  boundedChar: boundedChar,
  boundedOrdering: boundedOrdering,
  boundedUnit: boundedUnit,
  boundedNumber: boundedNumber
};
},{"./foreign.js":"../output/Data.Bounded/foreign.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Ordering/index.js":"../output/Data.Ordering/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.Functor.Invariant/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_Functor = require("../Data.Functor/index.js");

var Invariant = function Invariant(imap) {
  this.imap = imap;
};

var invariantMultiplicative = new Invariant(function (f) {
  return function (v) {
    return function (v1) {
      return f(v1);
    };
  };
});
var invariantEndo = new Invariant(function (ab) {
  return function (ba) {
    return function (v) {
      return function ($31) {
        return ab(v(ba($31)));
      };
    };
  };
});
var invariantDual = new Invariant(function (f) {
  return function (v) {
    return function (v1) {
      return f(v1);
    };
  };
});
var invariantDisj = new Invariant(function (f) {
  return function (v) {
    return function (v1) {
      return f(v1);
    };
  };
});
var invariantConj = new Invariant(function (f) {
  return function (v) {
    return function (v1) {
      return f(v1);
    };
  };
});
var invariantAdditive = new Invariant(function (f) {
  return function (v) {
    return function (v1) {
      return f(v1);
    };
  };
});

var imapF = function imapF(dictFunctor) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictFunctor)(f);
    };
  };
};

var invariantArray = new Invariant(imapF(Data_Functor.functorArray));
var invariantFn = new Invariant(imapF(Data_Functor.functorFn));

var imap = function imap(dict) {
  return dict.imap;
};

module.exports = {
  imap: imap,
  Invariant: Invariant,
  imapF: imapF,
  invariantFn: invariantFn,
  invariantArray: invariantArray,
  invariantAdditive: invariantAdditive,
  invariantConj: invariantConj,
  invariantDisj: invariantDisj,
  invariantDual: invariantDual,
  invariantEndo: invariantEndo,
  invariantMultiplicative: invariantMultiplicative
};
},{"../Data.Functor/index.js":"../output/Data.Functor/index.js"}],"../output/Data.EuclideanRing/foreign.js":[function(require,module,exports) {
"use strict";

exports.intDegree = function (x) {
  return Math.min(Math.abs(x), 2147483647);
}; // See the Euclidean definition in
// https://en.m.wikipedia.org/wiki/Modulo_operation.


exports.intDiv = function (x) {
  return function (y) {
    if (y === 0) return 0;
    return y > 0 ? Math.floor(x / y) : -Math.floor(x / -y);
  };
};

exports.intMod = function (x) {
  return function (y) {
    if (y === 0) return 0;
    var yy = Math.abs(y);
    return (x % yy + yy) % yy;
  };
};

exports.numDiv = function (n1) {
  return function (n2) {
    return n1 / n2;
  };
};
},{}],"../output/Data.CommutativeRing/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_Ring = require("../Data.Ring/index.js");

var CommutativeRingRecord = function CommutativeRingRecord(RingRecord0) {
  this.RingRecord0 = RingRecord0;
};

var CommutativeRing = function CommutativeRing(Ring0) {
  this.Ring0 = Ring0;
};

var commutativeRingUnit = new CommutativeRing(function () {
  return Data_Ring.ringUnit;
});
var commutativeRingRecordNil = new CommutativeRingRecord(function () {
  return Data_Ring.ringRecordNil;
});

var commutativeRingRecordCons = function commutativeRingRecordCons(dictIsSymbol) {
  return function (dictCons) {
    return function (dictCommutativeRingRecord) {
      return function (dictCommutativeRing) {
        return new CommutativeRingRecord(function () {
          return Data_Ring.ringRecordCons(dictIsSymbol)()(dictCommutativeRingRecord.RingRecord0())(dictCommutativeRing.Ring0());
        });
      };
    };
  };
};

var commutativeRingRecord = function commutativeRingRecord(dictRowToList) {
  return function (dictCommutativeRingRecord) {
    return new CommutativeRing(function () {
      return Data_Ring.ringRecord()(dictCommutativeRingRecord.RingRecord0());
    });
  };
};

var commutativeRingNumber = new CommutativeRing(function () {
  return Data_Ring.ringNumber;
});
var commutativeRingInt = new CommutativeRing(function () {
  return Data_Ring.ringInt;
});

var commutativeRingFn = function commutativeRingFn(dictCommutativeRing) {
  return new CommutativeRing(function () {
    return Data_Ring.ringFn(dictCommutativeRing.Ring0());
  });
};

module.exports = {
  CommutativeRing: CommutativeRing,
  CommutativeRingRecord: CommutativeRingRecord,
  commutativeRingInt: commutativeRingInt,
  commutativeRingNumber: commutativeRingNumber,
  commutativeRingUnit: commutativeRingUnit,
  commutativeRingFn: commutativeRingFn,
  commutativeRingRecord: commutativeRingRecord,
  commutativeRingRecordNil: commutativeRingRecordNil,
  commutativeRingRecordCons: commutativeRingRecordCons
};
},{"../Data.Ring/index.js":"../output/Data.Ring/index.js"}],"../output/Data.EuclideanRing/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_CommutativeRing = require("../Data.CommutativeRing/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Semiring = require("../Data.Semiring/index.js");

var EuclideanRing = function EuclideanRing(CommutativeRing0, degree, div, mod) {
  this.CommutativeRing0 = CommutativeRing0;
  this.degree = degree;
  this.div = div;
  this.mod = mod;
};

var mod = function mod(dict) {
  return dict.mod;
};

var gcd = function gcd($copy_dictEq) {
  return function ($copy_dictEuclideanRing) {
    return function ($copy_a) {
      return function ($copy_b) {
        var $tco_var_dictEq = $copy_dictEq;
        var $tco_var_dictEuclideanRing = $copy_dictEuclideanRing;
        var $tco_var_a = $copy_a;
        var $tco_done = false;
        var $tco_result;

        function $tco_loop(dictEq, dictEuclideanRing, a, b) {
          var $7 = Data_Eq.eq(dictEq)(b)(Data_Semiring.zero(dictEuclideanRing.CommutativeRing0().Ring0().Semiring0()));

          if ($7) {
            $tco_done = true;
            return a;
          }

          ;
          $tco_var_dictEq = dictEq;
          $tco_var_dictEuclideanRing = dictEuclideanRing;
          $tco_var_a = b;
          $copy_b = mod(dictEuclideanRing)(a)(b);
          return;
        }

        ;

        while (!$tco_done) {
          $tco_result = $tco_loop($tco_var_dictEq, $tco_var_dictEuclideanRing, $tco_var_a, $copy_b);
        }

        ;
        return $tco_result;
      };
    };
  };
};

var euclideanRingNumber = new EuclideanRing(function () {
  return Data_CommutativeRing.commutativeRingNumber;
}, function (v) {
  return 1;
}, $foreign.numDiv, function (v) {
  return function (v1) {
    return 0.0;
  };
});
var euclideanRingInt = new EuclideanRing(function () {
  return Data_CommutativeRing.commutativeRingInt;
}, $foreign.intDegree, $foreign.intDiv, $foreign.intMod);

var div = function div(dict) {
  return dict.div;
};

var lcm = function lcm(dictEq) {
  return function (dictEuclideanRing) {
    return function (a) {
      return function (b) {
        var $8 = Data_Eq.eq(dictEq)(a)(Data_Semiring.zero(dictEuclideanRing.CommutativeRing0().Ring0().Semiring0())) || Data_Eq.eq(dictEq)(b)(Data_Semiring.zero(dictEuclideanRing.CommutativeRing0().Ring0().Semiring0()));

        if ($8) {
          return Data_Semiring.zero(dictEuclideanRing.CommutativeRing0().Ring0().Semiring0());
        }

        ;
        return div(dictEuclideanRing)(Data_Semiring.mul(dictEuclideanRing.CommutativeRing0().Ring0().Semiring0())(a)(b))(gcd(dictEq)(dictEuclideanRing)(a)(b));
      };
    };
  };
};

var degree = function degree(dict) {
  return dict.degree;
};

module.exports = {
  EuclideanRing: EuclideanRing,
  degree: degree,
  div: div,
  mod: mod,
  gcd: gcd,
  lcm: lcm,
  euclideanRingInt: euclideanRingInt,
  euclideanRingNumber: euclideanRingNumber
};
},{"./foreign.js":"../output/Data.EuclideanRing/foreign.js","../Data.CommutativeRing/index.js":"../output/Data.CommutativeRing/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Semiring/index.js":"../output/Data.Semiring/index.js"}],"../output/Data.Monoid/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_Boolean = require("../Data.Boolean/index.js");

var Data_EuclideanRing = require("../Data.EuclideanRing/index.js");

var Data_Ordering = require("../Data.Ordering/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Symbol = require("../Data.Symbol/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Record_Unsafe = require("../Record.Unsafe/index.js");

var Type_Data_RowList = require("../Type.Data.RowList/index.js");

var MonoidRecord = function MonoidRecord(SemigroupRecord0, memptyRecord) {
  this.SemigroupRecord0 = SemigroupRecord0;
  this.memptyRecord = memptyRecord;
};

var Monoid = function Monoid(Semigroup0, mempty) {
  this.Semigroup0 = Semigroup0;
  this.mempty = mempty;
};

var monoidUnit = new Monoid(function () {
  return Data_Semigroup.semigroupUnit;
}, Data_Unit.unit);
var monoidString = new Monoid(function () {
  return Data_Semigroup.semigroupString;
}, "");
var monoidRecordNil = new MonoidRecord(function () {
  return Data_Semigroup.semigroupRecordNil;
}, function (v) {
  return {};
});
var monoidOrdering = new Monoid(function () {
  return Data_Ordering.semigroupOrdering;
}, Data_Ordering.EQ.value);
var monoidArray = new Monoid(function () {
  return Data_Semigroup.semigroupArray;
}, []);

var memptyRecord = function memptyRecord(dict) {
  return dict.memptyRecord;
};

var monoidRecord = function monoidRecord(dictRowToList) {
  return function (dictMonoidRecord) {
    return new Monoid(function () {
      return Data_Semigroup.semigroupRecord()(dictMonoidRecord.SemigroupRecord0());
    }, memptyRecord(dictMonoidRecord)(Type_Data_RowList.RLProxy.value));
  };
};

var mempty = function mempty(dict) {
  return dict.mempty;
};

var monoidFn = function monoidFn(dictMonoid) {
  return new Monoid(function () {
    return Data_Semigroup.semigroupFn(dictMonoid.Semigroup0());
  }, function (v) {
    return mempty(dictMonoid);
  });
};

var monoidRecordCons = function monoidRecordCons(dictIsSymbol) {
  return function (dictMonoid) {
    return function (dictCons) {
      return function (dictMonoidRecord) {
        return new MonoidRecord(function () {
          return Data_Semigroup.semigroupRecordCons(dictIsSymbol)()(dictMonoidRecord.SemigroupRecord0())(dictMonoid.Semigroup0());
        }, function (v) {
          var tail = memptyRecord(dictMonoidRecord)(Type_Data_RowList.RLProxy.value);
          var key = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
          var insert = Record_Unsafe.unsafeSet(key);
          return insert(mempty(dictMonoid))(tail);
        });
      };
    };
  };
};

var power = function power(dictMonoid) {
  return function (x) {
    var go = function go(p) {
      if (p <= 0) {
        return mempty(dictMonoid);
      }

      ;

      if (p === 1) {
        return x;
      }

      ;

      if (Data_EuclideanRing.mod(Data_EuclideanRing.euclideanRingInt)(p)(2) === 0) {
        var x$prime = go(Data_EuclideanRing.div(Data_EuclideanRing.euclideanRingInt)(p)(2));
        return Data_Semigroup.append(dictMonoid.Semigroup0())(x$prime)(x$prime);
      }

      ;

      if (Data_Boolean.otherwise) {
        var x$prime = go(Data_EuclideanRing.div(Data_EuclideanRing.euclideanRingInt)(p)(2));
        return Data_Semigroup.append(dictMonoid.Semigroup0())(x$prime)(Data_Semigroup.append(dictMonoid.Semigroup0())(x$prime)(x));
      }

      ;
      throw new Error("Failed pattern match at Data.Monoid (line 65, column 3 - line 65, column 17): " + [p.constructor.name]);
    };

    return go;
  };
};

var guard = function guard(dictMonoid) {
  return function (v) {
    return function (v1) {
      if (v) {
        return v1;
      }

      ;

      if (!v) {
        return mempty(dictMonoid);
      }

      ;
      throw new Error("Failed pattern match at Data.Monoid (line 73, column 1 - line 73, column 49): " + [v.constructor.name, v1.constructor.name]);
    };
  };
};

module.exports = {
  Monoid: Monoid,
  mempty: mempty,
  power: power,
  guard: guard,
  MonoidRecord: MonoidRecord,
  memptyRecord: memptyRecord,
  monoidUnit: monoidUnit,
  monoidOrdering: monoidOrdering,
  monoidFn: monoidFn,
  monoidString: monoidString,
  monoidArray: monoidArray,
  monoidRecord: monoidRecord,
  monoidRecordNil: monoidRecordNil,
  monoidRecordCons: monoidRecordCons
};
},{"../Data.Boolean/index.js":"../output/Data.Boolean/index.js","../Data.EuclideanRing/index.js":"../output/Data.EuclideanRing/index.js","../Data.Ordering/index.js":"../output/Data.Ordering/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Symbol/index.js":"../output/Data.Symbol/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js","../Record.Unsafe/index.js":"../output/Record.Unsafe/index.js","../Type.Data.RowList/index.js":"../output/Type.Data.RowList/index.js"}],"../output/Data.Maybe/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Alt = require("../Control.Alt/index.js");

var Control_Alternative = require("../Control.Alternative/index.js");

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Category = require("../Control.Category/index.js");

var Control_Extend = require("../Control.Extend/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Control_MonadZero = require("../Control.MonadZero/index.js");

var Control_Plus = require("../Control.Plus/index.js");

var Data_Bounded = require("../Data.Bounded/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Function = require("../Data.Function/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Functor_Invariant = require("../Data.Functor.Invariant/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Ordering = require("../Data.Ordering/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Show = require("../Data.Show/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Nothing = function () {
  function Nothing() {}

  ;
  Nothing.value = new Nothing();
  return Nothing;
}();

var Just = function () {
  function Just(value0) {
    this.value0 = value0;
  }

  ;

  Just.create = function (value0) {
    return new Just(value0);
  };

  return Just;
}();

var showMaybe = function showMaybe(dictShow) {
  return new Data_Show.Show(function (v) {
    if (v instanceof Just) {
      return "(Just " + (Data_Show.show(dictShow)(v.value0) + ")");
    }

    ;

    if (v instanceof Nothing) {
      return "Nothing";
    }

    ;
    throw new Error("Failed pattern match at Data.Maybe (line 205, column 1 - line 207, column 28): " + [v.constructor.name]);
  });
};

var semigroupMaybe = function semigroupMaybe(dictSemigroup) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      if (v instanceof Nothing) {
        return v1;
      }

      ;

      if (v1 instanceof Nothing) {
        return v;
      }

      ;

      if (v instanceof Just && v1 instanceof Just) {
        return new Just(Data_Semigroup.append(dictSemigroup)(v.value0)(v1.value0));
      }

      ;
      throw new Error("Failed pattern match at Data.Maybe (line 174, column 1 - line 177, column 43): " + [v.constructor.name, v1.constructor.name]);
    };
  });
};

var optional = function optional(dictAlternative) {
  return function (a) {
    return Control_Alt.alt(dictAlternative.Plus1().Alt0())(Data_Functor.map(dictAlternative.Plus1().Alt0().Functor0())(Just.create)(a))(Control_Applicative.pure(dictAlternative.Applicative0())(Nothing.value));
  };
};

var monoidMaybe = function monoidMaybe(dictSemigroup) {
  return new Data_Monoid.Monoid(function () {
    return semigroupMaybe(dictSemigroup);
  }, Nothing.value);
};

var maybe$prime = function maybe$prime(v) {
  return function (v1) {
    return function (v2) {
      if (v2 instanceof Nothing) {
        return v(Data_Unit.unit);
      }

      ;

      if (v2 instanceof Just) {
        return v1(v2.value0);
      }

      ;
      throw new Error("Failed pattern match at Data.Maybe (line 230, column 1 - line 230, column 62): " + [v.constructor.name, v1.constructor.name, v2.constructor.name]);
    };
  };
};

var maybe = function maybe(v) {
  return function (v1) {
    return function (v2) {
      if (v2 instanceof Nothing) {
        return v;
      }

      ;

      if (v2 instanceof Just) {
        return v1(v2.value0);
      }

      ;
      throw new Error("Failed pattern match at Data.Maybe (line 217, column 1 - line 217, column 51): " + [v.constructor.name, v1.constructor.name, v2.constructor.name]);
    };
  };
};

var isNothing = maybe(true)(Data_Function["const"](false));
var isJust = maybe(false)(Data_Function["const"](true));
var functorMaybe = new Data_Functor.Functor(function (v) {
  return function (v1) {
    if (v1 instanceof Just) {
      return new Just(v(v1.value0));
    }

    ;
    return Nothing.value;
  };
});
var invariantMaybe = new Data_Functor_Invariant.Invariant(Data_Functor_Invariant.imapF(functorMaybe));

var fromMaybe$prime = function fromMaybe$prime(a) {
  return maybe$prime(a)(Control_Category.identity(Control_Category.categoryFn));
};

var fromMaybe = function fromMaybe(a) {
  return maybe(a)(Control_Category.identity(Control_Category.categoryFn));
};

var fromJust = function fromJust(dictPartial) {
  return function (v) {
    if (v instanceof Just) {
      return v.value0;
    }

    ;
    throw new Error("Failed pattern match at Data.Maybe (line 268, column 1 - line 268, column 46): " + [v.constructor.name]);
  };
};

var extendMaybe = new Control_Extend.Extend(function () {
  return functorMaybe;
}, function (v) {
  return function (v1) {
    if (v1 instanceof Nothing) {
      return Nothing.value;
    }

    ;
    return new Just(v(v1));
  };
});

var eqMaybe = function eqMaybe(dictEq) {
  return new Data_Eq.Eq(function (x) {
    return function (y) {
      if (x instanceof Nothing && y instanceof Nothing) {
        return true;
      }

      ;

      if (x instanceof Just && y instanceof Just) {
        return Data_Eq.eq(dictEq)(x.value0)(y.value0);
      }

      ;
      return false;
    };
  });
};

var ordMaybe = function ordMaybe(dictOrd) {
  return new Data_Ord.Ord(function () {
    return eqMaybe(dictOrd.Eq0());
  }, function (x) {
    return function (y) {
      if (x instanceof Nothing && y instanceof Nothing) {
        return Data_Ordering.EQ.value;
      }

      ;

      if (x instanceof Nothing) {
        return Data_Ordering.LT.value;
      }

      ;

      if (y instanceof Nothing) {
        return Data_Ordering.GT.value;
      }

      ;

      if (x instanceof Just && y instanceof Just) {
        return Data_Ord.compare(dictOrd)(x.value0)(y.value0);
      }

      ;
      throw new Error("Failed pattern match at Data.Maybe (line 194, column 1 - line 194, column 51): " + [x.constructor.name, y.constructor.name]);
    };
  });
};

var eq1Maybe = new Data_Eq.Eq1(function (dictEq) {
  return Data_Eq.eq(eqMaybe(dictEq));
});
var ord1Maybe = new Data_Ord.Ord1(function () {
  return eq1Maybe;
}, function (dictOrd) {
  return Data_Ord.compare(ordMaybe(dictOrd));
});

var boundedMaybe = function boundedMaybe(dictBounded) {
  return new Data_Bounded.Bounded(function () {
    return ordMaybe(dictBounded.Ord0());
  }, Nothing.value, new Just(Data_Bounded.top(dictBounded)));
};

var applyMaybe = new Control_Apply.Apply(function () {
  return functorMaybe;
}, function (v) {
  return function (v1) {
    if (v instanceof Just) {
      return Data_Functor.map(functorMaybe)(v.value0)(v1);
    }

    ;

    if (v instanceof Nothing) {
      return Nothing.value;
    }

    ;
    throw new Error("Failed pattern match at Data.Maybe (line 67, column 1 - line 69, column 30): " + [v.constructor.name, v1.constructor.name]);
  };
});
var bindMaybe = new Control_Bind.Bind(function () {
  return applyMaybe;
}, function (v) {
  return function (v1) {
    if (v instanceof Just) {
      return v1(v.value0);
    }

    ;

    if (v instanceof Nothing) {
      return Nothing.value;
    }

    ;
    throw new Error("Failed pattern match at Data.Maybe (line 125, column 1 - line 127, column 28): " + [v.constructor.name, v1.constructor.name]);
  };
});
var applicativeMaybe = new Control_Applicative.Applicative(function () {
  return applyMaybe;
}, Just.create);
var monadMaybe = new Control_Monad.Monad(function () {
  return applicativeMaybe;
}, function () {
  return bindMaybe;
});
var altMaybe = new Control_Alt.Alt(function () {
  return functorMaybe;
}, function (v) {
  return function (v1) {
    if (v instanceof Nothing) {
      return v1;
    }

    ;
    return v;
  };
});
var plusMaybe = new Control_Plus.Plus(function () {
  return altMaybe;
}, Nothing.value);
var alternativeMaybe = new Control_Alternative.Alternative(function () {
  return applicativeMaybe;
}, function () {
  return plusMaybe;
});
var monadZeroMaybe = new Control_MonadZero.MonadZero(function () {
  return alternativeMaybe;
}, function () {
  return monadMaybe;
});
module.exports = {
  Nothing: Nothing,
  Just: Just,
  maybe: maybe,
  "maybe'": maybe$prime,
  fromMaybe: fromMaybe,
  "fromMaybe'": fromMaybe$prime,
  isJust: isJust,
  isNothing: isNothing,
  fromJust: fromJust,
  optional: optional,
  functorMaybe: functorMaybe,
  applyMaybe: applyMaybe,
  applicativeMaybe: applicativeMaybe,
  altMaybe: altMaybe,
  plusMaybe: plusMaybe,
  alternativeMaybe: alternativeMaybe,
  bindMaybe: bindMaybe,
  monadMaybe: monadMaybe,
  monadZeroMaybe: monadZeroMaybe,
  extendMaybe: extendMaybe,
  invariantMaybe: invariantMaybe,
  semigroupMaybe: semigroupMaybe,
  monoidMaybe: monoidMaybe,
  eqMaybe: eqMaybe,
  eq1Maybe: eq1Maybe,
  ordMaybe: ordMaybe,
  ord1Maybe: ord1Maybe,
  boundedMaybe: boundedMaybe,
  showMaybe: showMaybe
};
},{"../Control.Alt/index.js":"../output/Control.Alt/index.js","../Control.Alternative/index.js":"../output/Control.Alternative/index.js","../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Control.Extend/index.js":"../output/Control.Extend/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Control.MonadZero/index.js":"../output/Control.MonadZero/index.js","../Control.Plus/index.js":"../output/Control.Plus/index.js","../Data.Bounded/index.js":"../output/Data.Bounded/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Functor.Invariant/index.js":"../output/Data.Functor.Invariant/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Ordering/index.js":"../output/Data.Ordering/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Show/index.js":"../output/Data.Show/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.Monoid.Conj/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_HeytingAlgebra = require("../Data.HeytingAlgebra/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Semiring = require("../Data.Semiring/index.js");

var Data_Show = require("../Data.Show/index.js");

var Conj = function Conj(x) {
  return x;
};

var showConj = function showConj(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Conj " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semiringConj = function semiringConj(dictHeytingAlgebra) {
  return new Data_Semiring.Semiring(function (v) {
    return function (v1) {
      return Data_HeytingAlgebra.conj(dictHeytingAlgebra)(v)(v1);
    };
  }, function (v) {
    return function (v1) {
      return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);
    };
  }, Data_HeytingAlgebra.ff(dictHeytingAlgebra), Data_HeytingAlgebra.tt(dictHeytingAlgebra));
};

var semigroupConj = function semigroupConj(dictHeytingAlgebra) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      return Data_HeytingAlgebra.conj(dictHeytingAlgebra)(v)(v1);
    };
  });
};

var ordConj = function ordConj(dictOrd) {
  return dictOrd;
};

var monoidConj = function monoidConj(dictHeytingAlgebra) {
  return new Data_Monoid.Monoid(function () {
    return semigroupConj(dictHeytingAlgebra);
  }, Data_HeytingAlgebra.tt(dictHeytingAlgebra));
};

var functorConj = new Data_Functor.Functor(function (f) {
  return function (m) {
    return f(m);
  };
});

var eqConj = function eqConj(dictEq) {
  return dictEq;
};

var eq1Conj = new Data_Eq.Eq1(function (dictEq) {
  return Data_Eq.eq(eqConj(dictEq));
});
var ord1Conj = new Data_Ord.Ord1(function () {
  return eq1Conj;
}, function (dictOrd) {
  return Data_Ord.compare(ordConj(dictOrd));
});

var boundedConj = function boundedConj(dictBounded) {
  return dictBounded;
};

var applyConj = new Control_Apply.Apply(function () {
  return functorConj;
}, function (v) {
  return function (v1) {
    return v(v1);
  };
});
var bindConj = new Control_Bind.Bind(function () {
  return applyConj;
}, function (v) {
  return function (f) {
    return f(v);
  };
});
var applicativeConj = new Control_Applicative.Applicative(function () {
  return applyConj;
}, Conj);
var monadConj = new Control_Monad.Monad(function () {
  return applicativeConj;
}, function () {
  return bindConj;
});
module.exports = {
  Conj: Conj,
  eqConj: eqConj,
  eq1Conj: eq1Conj,
  ordConj: ordConj,
  ord1Conj: ord1Conj,
  boundedConj: boundedConj,
  showConj: showConj,
  functorConj: functorConj,
  applyConj: applyConj,
  applicativeConj: applicativeConj,
  bindConj: bindConj,
  monadConj: monadConj,
  semigroupConj: semigroupConj,
  monoidConj: monoidConj,
  semiringConj: semiringConj
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.HeytingAlgebra/index.js":"../output/Data.HeytingAlgebra/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Semiring/index.js":"../output/Data.Semiring/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Monoid.Disj/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_HeytingAlgebra = require("../Data.HeytingAlgebra/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Semiring = require("../Data.Semiring/index.js");

var Data_Show = require("../Data.Show/index.js");

var Disj = function Disj(x) {
  return x;
};

var showDisj = function showDisj(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Disj " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semiringDisj = function semiringDisj(dictHeytingAlgebra) {
  return new Data_Semiring.Semiring(function (v) {
    return function (v1) {
      return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);
    };
  }, function (v) {
    return function (v1) {
      return Data_HeytingAlgebra.conj(dictHeytingAlgebra)(v)(v1);
    };
  }, Data_HeytingAlgebra.tt(dictHeytingAlgebra), Data_HeytingAlgebra.ff(dictHeytingAlgebra));
};

var semigroupDisj = function semigroupDisj(dictHeytingAlgebra) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);
    };
  });
};

var ordDisj = function ordDisj(dictOrd) {
  return dictOrd;
};

var monoidDisj = function monoidDisj(dictHeytingAlgebra) {
  return new Data_Monoid.Monoid(function () {
    return semigroupDisj(dictHeytingAlgebra);
  }, Data_HeytingAlgebra.ff(dictHeytingAlgebra));
};

var functorDisj = new Data_Functor.Functor(function (f) {
  return function (m) {
    return f(m);
  };
});

var eqDisj = function eqDisj(dictEq) {
  return dictEq;
};

var eq1Disj = new Data_Eq.Eq1(function (dictEq) {
  return Data_Eq.eq(eqDisj(dictEq));
});
var ord1Disj = new Data_Ord.Ord1(function () {
  return eq1Disj;
}, function (dictOrd) {
  return Data_Ord.compare(ordDisj(dictOrd));
});

var boundedDisj = function boundedDisj(dictBounded) {
  return dictBounded;
};

var applyDisj = new Control_Apply.Apply(function () {
  return functorDisj;
}, function (v) {
  return function (v1) {
    return v(v1);
  };
});
var bindDisj = new Control_Bind.Bind(function () {
  return applyDisj;
}, function (v) {
  return function (f) {
    return f(v);
  };
});
var applicativeDisj = new Control_Applicative.Applicative(function () {
  return applyDisj;
}, Disj);
var monadDisj = new Control_Monad.Monad(function () {
  return applicativeDisj;
}, function () {
  return bindDisj;
});
module.exports = {
  Disj: Disj,
  eqDisj: eqDisj,
  eq1Disj: eq1Disj,
  ordDisj: ordDisj,
  ord1Disj: ord1Disj,
  boundedDisj: boundedDisj,
  showDisj: showDisj,
  functorDisj: functorDisj,
  applyDisj: applyDisj,
  applicativeDisj: applicativeDisj,
  bindDisj: bindDisj,
  monadDisj: monadDisj,
  semigroupDisj: semigroupDisj,
  monoidDisj: monoidDisj,
  semiringDisj: semiringDisj
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.HeytingAlgebra/index.js":"../output/Data.HeytingAlgebra/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Semiring/index.js":"../output/Data.Semiring/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Monoid.Dual/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Show = require("../Data.Show/index.js");

var Dual = function Dual(x) {
  return x;
};

var showDual = function showDual(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Dual " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semigroupDual = function semigroupDual(dictSemigroup) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      return Data_Semigroup.append(dictSemigroup)(v1)(v);
    };
  });
};

var ordDual = function ordDual(dictOrd) {
  return dictOrd;
};

var monoidDual = function monoidDual(dictMonoid) {
  return new Data_Monoid.Monoid(function () {
    return semigroupDual(dictMonoid.Semigroup0());
  }, Data_Monoid.mempty(dictMonoid));
};

var functorDual = new Data_Functor.Functor(function (f) {
  return function (m) {
    return f(m);
  };
});

var eqDual = function eqDual(dictEq) {
  return dictEq;
};

var eq1Dual = new Data_Eq.Eq1(function (dictEq) {
  return Data_Eq.eq(eqDual(dictEq));
});
var ord1Dual = new Data_Ord.Ord1(function () {
  return eq1Dual;
}, function (dictOrd) {
  return Data_Ord.compare(ordDual(dictOrd));
});

var boundedDual = function boundedDual(dictBounded) {
  return dictBounded;
};

var applyDual = new Control_Apply.Apply(function () {
  return functorDual;
}, function (v) {
  return function (v1) {
    return v(v1);
  };
});
var bindDual = new Control_Bind.Bind(function () {
  return applyDual;
}, function (v) {
  return function (f) {
    return f(v);
  };
});
var applicativeDual = new Control_Applicative.Applicative(function () {
  return applyDual;
}, Dual);
var monadDual = new Control_Monad.Monad(function () {
  return applicativeDual;
}, function () {
  return bindDual;
});
module.exports = {
  Dual: Dual,
  eqDual: eqDual,
  eq1Dual: eq1Dual,
  ordDual: ordDual,
  ord1Dual: ord1Dual,
  boundedDual: boundedDual,
  showDual: showDual,
  functorDual: functorDual,
  applyDual: applyDual,
  applicativeDual: applicativeDual,
  bindDual: bindDual,
  monadDual: monadDual,
  semigroupDual: semigroupDual,
  monoidDual: monoidDual
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Monoid.Endo/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Category = require("../Control.Category/index.js");

var Control_Semigroupoid = require("../Control.Semigroupoid/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Show = require("../Data.Show/index.js");

var Endo = function Endo(x) {
  return x;
};

var showEndo = function showEndo(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Endo " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semigroupEndo = function semigroupEndo(dictSemigroupoid) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      return Control_Semigroupoid.compose(dictSemigroupoid)(v)(v1);
    };
  });
};

var ordEndo = function ordEndo(dictOrd) {
  return dictOrd;
};

var monoidEndo = function monoidEndo(dictCategory) {
  return new Data_Monoid.Monoid(function () {
    return semigroupEndo(dictCategory.Semigroupoid0());
  }, Control_Category.identity(dictCategory));
};

var eqEndo = function eqEndo(dictEq) {
  return dictEq;
};

var boundedEndo = function boundedEndo(dictBounded) {
  return dictBounded;
};

module.exports = {
  Endo: Endo,
  eqEndo: eqEndo,
  ordEndo: ordEndo,
  boundedEndo: boundedEndo,
  showEndo: showEndo,
  semigroupEndo: semigroupEndo,
  monoidEndo: monoidEndo
};
},{"../Control.Category/index.js":"../output/Control.Category/index.js","../Control.Semigroupoid/index.js":"../output/Control.Semigroupoid/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Monoid.Additive/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Semiring = require("../Data.Semiring/index.js");

var Data_Show = require("../Data.Show/index.js");

var Additive = function Additive(x) {
  return x;
};

var showAdditive = function showAdditive(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Additive " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semigroupAdditive = function semigroupAdditive(dictSemiring) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      return Data_Semiring.add(dictSemiring)(v)(v1);
    };
  });
};

var ordAdditive = function ordAdditive(dictOrd) {
  return dictOrd;
};

var monoidAdditive = function monoidAdditive(dictSemiring) {
  return new Data_Monoid.Monoid(function () {
    return semigroupAdditive(dictSemiring);
  }, Data_Semiring.zero(dictSemiring));
};

var functorAdditive = new Data_Functor.Functor(function (f) {
  return function (m) {
    return f(m);
  };
});

var eqAdditive = function eqAdditive(dictEq) {
  return dictEq;
};

var eq1Additive = new Data_Eq.Eq1(function (dictEq) {
  return Data_Eq.eq(eqAdditive(dictEq));
});
var ord1Additive = new Data_Ord.Ord1(function () {
  return eq1Additive;
}, function (dictOrd) {
  return Data_Ord.compare(ordAdditive(dictOrd));
});

var boundedAdditive = function boundedAdditive(dictBounded) {
  return dictBounded;
};

var applyAdditive = new Control_Apply.Apply(function () {
  return functorAdditive;
}, function (v) {
  return function (v1) {
    return v(v1);
  };
});
var bindAdditive = new Control_Bind.Bind(function () {
  return applyAdditive;
}, function (v) {
  return function (f) {
    return f(v);
  };
});
var applicativeAdditive = new Control_Applicative.Applicative(function () {
  return applyAdditive;
}, Additive);
var monadAdditive = new Control_Monad.Monad(function () {
  return applicativeAdditive;
}, function () {
  return bindAdditive;
});
module.exports = {
  Additive: Additive,
  eqAdditive: eqAdditive,
  eq1Additive: eq1Additive,
  ordAdditive: ordAdditive,
  ord1Additive: ord1Additive,
  boundedAdditive: boundedAdditive,
  showAdditive: showAdditive,
  functorAdditive: functorAdditive,
  applyAdditive: applyAdditive,
  applicativeAdditive: applicativeAdditive,
  bindAdditive: bindAdditive,
  monadAdditive: monadAdditive,
  semigroupAdditive: semigroupAdditive,
  monoidAdditive: monoidAdditive
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Semiring/index.js":"../output/Data.Semiring/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Monoid.Multiplicative/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Semiring = require("../Data.Semiring/index.js");

var Data_Show = require("../Data.Show/index.js");

var Multiplicative = function Multiplicative(x) {
  return x;
};

var showMultiplicative = function showMultiplicative(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Multiplicative " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semigroupMultiplicative = function semigroupMultiplicative(dictSemiring) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      return Data_Semiring.mul(dictSemiring)(v)(v1);
    };
  });
};

var ordMultiplicative = function ordMultiplicative(dictOrd) {
  return dictOrd;
};

var monoidMultiplicative = function monoidMultiplicative(dictSemiring) {
  return new Data_Monoid.Monoid(function () {
    return semigroupMultiplicative(dictSemiring);
  }, Data_Semiring.one(dictSemiring));
};

var functorMultiplicative = new Data_Functor.Functor(function (f) {
  return function (m) {
    return f(m);
  };
});

var eqMultiplicative = function eqMultiplicative(dictEq) {
  return dictEq;
};

var eq1Multiplicative = new Data_Eq.Eq1(function (dictEq) {
  return Data_Eq.eq(eqMultiplicative(dictEq));
});
var ord1Multiplicative = new Data_Ord.Ord1(function () {
  return eq1Multiplicative;
}, function (dictOrd) {
  return Data_Ord.compare(ordMultiplicative(dictOrd));
});

var boundedMultiplicative = function boundedMultiplicative(dictBounded) {
  return dictBounded;
};

var applyMultiplicative = new Control_Apply.Apply(function () {
  return functorMultiplicative;
}, function (v) {
  return function (v1) {
    return v(v1);
  };
});
var bindMultiplicative = new Control_Bind.Bind(function () {
  return applyMultiplicative;
}, function (v) {
  return function (f) {
    return f(v);
  };
});
var applicativeMultiplicative = new Control_Applicative.Applicative(function () {
  return applyMultiplicative;
}, Multiplicative);
var monadMultiplicative = new Control_Monad.Monad(function () {
  return applicativeMultiplicative;
}, function () {
  return bindMultiplicative;
});
module.exports = {
  Multiplicative: Multiplicative,
  eqMultiplicative: eqMultiplicative,
  eq1Multiplicative: eq1Multiplicative,
  ordMultiplicative: ordMultiplicative,
  ord1Multiplicative: ord1Multiplicative,
  boundedMultiplicative: boundedMultiplicative,
  showMultiplicative: showMultiplicative,
  functorMultiplicative: functorMultiplicative,
  applyMultiplicative: applyMultiplicative,
  applicativeMultiplicative: applicativeMultiplicative,
  bindMultiplicative: bindMultiplicative,
  monadMultiplicative: monadMultiplicative,
  semigroupMultiplicative: semigroupMultiplicative,
  monoidMultiplicative: monoidMultiplicative
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Semiring/index.js":"../output/Data.Semiring/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Semigroup.First/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Show = require("../Data.Show/index.js");

var First = function First(x) {
  return x;
};

var showFirst = function showFirst(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(First " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semigroupFirst = new Data_Semigroup.Semigroup(function (x) {
  return function (v) {
    return x;
  };
});

var ordFirst = function ordFirst(dictOrd) {
  return dictOrd;
};

var functorFirst = new Data_Functor.Functor(function (f) {
  return function (m) {
    return f(m);
  };
});

var eqFirst = function eqFirst(dictEq) {
  return dictEq;
};

var eq1First = new Data_Eq.Eq1(function (dictEq) {
  return Data_Eq.eq(eqFirst(dictEq));
});
var ord1First = new Data_Ord.Ord1(function () {
  return eq1First;
}, function (dictOrd) {
  return Data_Ord.compare(ordFirst(dictOrd));
});

var boundedFirst = function boundedFirst(dictBounded) {
  return dictBounded;
};

var applyFirst = new Control_Apply.Apply(function () {
  return functorFirst;
}, function (v) {
  return function (v1) {
    return v(v1);
  };
});
var bindFirst = new Control_Bind.Bind(function () {
  return applyFirst;
}, function (v) {
  return function (f) {
    return f(v);
  };
});
var applicativeFirst = new Control_Applicative.Applicative(function () {
  return applyFirst;
}, First);
var monadFirst = new Control_Monad.Monad(function () {
  return applicativeFirst;
}, function () {
  return bindFirst;
});
module.exports = {
  First: First,
  eqFirst: eqFirst,
  eq1First: eq1First,
  ordFirst: ordFirst,
  ord1First: ord1First,
  boundedFirst: boundedFirst,
  showFirst: showFirst,
  functorFirst: functorFirst,
  applyFirst: applyFirst,
  applicativeFirst: applicativeFirst,
  bindFirst: bindFirst,
  monadFirst: monadFirst,
  semigroupFirst: semigroupFirst
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Semigroup.Last/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Show = require("../Data.Show/index.js");

var Last = function Last(x) {
  return x;
};

var showLast = function showLast(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Last " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semigroupLast = new Data_Semigroup.Semigroup(function (v) {
  return function (x) {
    return x;
  };
});

var ordLast = function ordLast(dictOrd) {
  return dictOrd;
};

var functorLast = new Data_Functor.Functor(function (f) {
  return function (m) {
    return f(m);
  };
});

var eqLast = function eqLast(dictEq) {
  return dictEq;
};

var eq1Last = new Data_Eq.Eq1(function (dictEq) {
  return Data_Eq.eq(eqLast(dictEq));
});
var ord1Last = new Data_Ord.Ord1(function () {
  return eq1Last;
}, function (dictOrd) {
  return Data_Ord.compare(ordLast(dictOrd));
});

var boundedLast = function boundedLast(dictBounded) {
  return dictBounded;
};

var applyLast = new Control_Apply.Apply(function () {
  return functorLast;
}, function (v) {
  return function (v1) {
    return v(v1);
  };
});
var bindLast = new Control_Bind.Bind(function () {
  return applyLast;
}, function (v) {
  return function (f) {
    return f(v);
  };
});
var applicativeLast = new Control_Applicative.Applicative(function () {
  return applyLast;
}, Last);
var monadLast = new Control_Monad.Monad(function () {
  return applicativeLast;
}, function () {
  return bindLast;
});
module.exports = {
  Last: Last,
  eqLast: eqLast,
  eq1Last: eq1Last,
  ordLast: ordLast,
  ord1Last: ord1Last,
  boundedLast: boundedLast,
  showLast: showLast,
  functorLast: functorLast,
  applyLast: applyLast,
  applicativeLast: applicativeLast,
  bindLast: bindLast,
  monadLast: monadLast,
  semigroupLast: semigroupLast
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Newtype/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Semigroupoid = require("../Control.Semigroupoid/index.js");

var Data_Function = require("../Data.Function/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Monoid_Additive = require("../Data.Monoid.Additive/index.js");

var Data_Monoid_Conj = require("../Data.Monoid.Conj/index.js");

var Data_Monoid_Disj = require("../Data.Monoid.Disj/index.js");

var Data_Monoid_Dual = require("../Data.Monoid.Dual/index.js");

var Data_Monoid_Endo = require("../Data.Monoid.Endo/index.js");

var Data_Monoid_Multiplicative = require("../Data.Monoid.Multiplicative/index.js");

var Data_Semigroup_First = require("../Data.Semigroup.First/index.js");

var Data_Semigroup_Last = require("../Data.Semigroup.Last/index.js");

var Newtype = function Newtype(unwrap, wrap) {
  this.unwrap = unwrap;
  this.wrap = wrap;
};

var wrap = function wrap(dict) {
  return dict.wrap;
};

var unwrap = function unwrap(dict) {
  return dict.unwrap;
};

var underF2 = function underF2(dictFunctor) {
  return function (dictFunctor1) {
    return function (dictNewtype) {
      return function (dictNewtype1) {
        return function (v) {
          return function (f) {
            var $66 = Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn)(Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1)));
            var $67 = Data_Function.on(f)(Data_Functor.map(dictFunctor)(wrap(dictNewtype)));
            return function ($68) {
              return $66($67($68));
            };
          };
        };
      };
    };
  };
};

var underF = function underF(dictFunctor) {
  return function (dictFunctor1) {
    return function (dictNewtype) {
      return function (dictNewtype1) {
        return function (v) {
          return function (f) {
            var $69 = Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1));
            var $70 = Data_Functor.map(dictFunctor)(wrap(dictNewtype));
            return function ($71) {
              return $69(f($70($71)));
            };
          };
        };
      };
    };
  };
};

var under2 = function under2(dictNewtype) {
  return function (dictNewtype1) {
    return function (v) {
      return function (f) {
        var $72 = Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn)(unwrap(dictNewtype1));
        var $73 = Data_Function.on(f)(wrap(dictNewtype));
        return function ($74) {
          return $72($73($74));
        };
      };
    };
  };
};

var under = function under(dictNewtype) {
  return function (dictNewtype1) {
    return function (v) {
      return function (f) {
        var $75 = unwrap(dictNewtype1);
        var $76 = wrap(dictNewtype);
        return function ($77) {
          return $75(f($76($77)));
        };
      };
    };
  };
};

var un = function un(dictNewtype) {
  return function (v) {
    return unwrap(dictNewtype);
  };
};

var traverse = function traverse(dictFunctor) {
  return function (dictNewtype) {
    return function (v) {
      return function (f) {
        var $78 = Data_Functor.map(dictFunctor)(wrap(dictNewtype));
        var $79 = unwrap(dictNewtype);
        return function ($80) {
          return $78(f($79($80)));
        };
      };
    };
  };
};

var overF2 = function overF2(dictFunctor) {
  return function (dictFunctor1) {
    return function (dictNewtype) {
      return function (dictNewtype1) {
        return function (v) {
          return function (f) {
            var $81 = Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn)(Data_Functor.map(dictFunctor1)(wrap(dictNewtype1)));
            var $82 = Data_Function.on(f)(Data_Functor.map(dictFunctor)(unwrap(dictNewtype)));
            return function ($83) {
              return $81($82($83));
            };
          };
        };
      };
    };
  };
};

var overF = function overF(dictFunctor) {
  return function (dictFunctor1) {
    return function (dictNewtype) {
      return function (dictNewtype1) {
        return function (v) {
          return function (f) {
            var $84 = Data_Functor.map(dictFunctor1)(wrap(dictNewtype1));
            var $85 = Data_Functor.map(dictFunctor)(unwrap(dictNewtype));
            return function ($86) {
              return $84(f($85($86)));
            };
          };
        };
      };
    };
  };
};

var over2 = function over2(dictNewtype) {
  return function (dictNewtype1) {
    return function (v) {
      return function (f) {
        var $87 = Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn)(wrap(dictNewtype1));
        var $88 = Data_Function.on(f)(unwrap(dictNewtype));
        return function ($89) {
          return $87($88($89));
        };
      };
    };
  };
};

var over = function over(dictNewtype) {
  return function (dictNewtype1) {
    return function (v) {
      return function (f) {
        var $90 = wrap(dictNewtype1);
        var $91 = unwrap(dictNewtype);
        return function ($92) {
          return $90(f($91($92)));
        };
      };
    };
  };
};

var op = function op(dictNewtype) {
  return un(dictNewtype);
};

var newtypeMultiplicative = new Newtype(function (v) {
  return v;
}, Data_Monoid_Multiplicative.Multiplicative);
var newtypeLast = new Newtype(function (v) {
  return v;
}, Data_Semigroup_Last.Last);
var newtypeFirst = new Newtype(function (v) {
  return v;
}, Data_Semigroup_First.First);
var newtypeEndo = new Newtype(function (v) {
  return v;
}, Data_Monoid_Endo.Endo);
var newtypeDual = new Newtype(function (v) {
  return v;
}, Data_Monoid_Dual.Dual);
var newtypeDisj = new Newtype(function (v) {
  return v;
}, Data_Monoid_Disj.Disj);
var newtypeConj = new Newtype(function (v) {
  return v;
}, Data_Monoid_Conj.Conj);
var newtypeAdditive = new Newtype(function (v) {
  return v;
}, Data_Monoid_Additive.Additive);

var collect = function collect(dictFunctor) {
  return function (dictNewtype) {
    return function (v) {
      return function (f) {
        var $93 = wrap(dictNewtype);
        var $94 = Data_Functor.map(dictFunctor)(unwrap(dictNewtype));
        return function ($95) {
          return $93(f($94($95)));
        };
      };
    };
  };
};

var alaF = function alaF(dictFunctor) {
  return function (dictFunctor1) {
    return function (dictNewtype) {
      return function (dictNewtype1) {
        return function (v) {
          return function (f) {
            var $96 = Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1));
            var $97 = Data_Functor.map(dictFunctor)(wrap(dictNewtype));
            return function ($98) {
              return $96(f($97($98)));
            };
          };
        };
      };
    };
  };
};

var ala = function ala(dictFunctor) {
  return function (dictNewtype) {
    return function (dictNewtype1) {
      return function (v) {
        return function (f) {
          return Data_Functor.map(dictFunctor)(unwrap(dictNewtype))(f(wrap(dictNewtype1)));
        };
      };
    };
  };
};

module.exports = {
  unwrap: unwrap,
  wrap: wrap,
  Newtype: Newtype,
  un: un,
  op: op,
  ala: ala,
  alaF: alaF,
  over: over,
  overF: overF,
  under: under,
  underF: underF,
  over2: over2,
  overF2: overF2,
  under2: under2,
  underF2: underF2,
  traverse: traverse,
  collect: collect,
  newtypeAdditive: newtypeAdditive,
  newtypeMultiplicative: newtypeMultiplicative,
  newtypeConj: newtypeConj,
  newtypeDisj: newtypeDisj,
  newtypeDual: newtypeDual,
  newtypeEndo: newtypeEndo,
  newtypeFirst: newtypeFirst,
  newtypeLast: newtypeLast
};
},{"../Control.Semigroupoid/index.js":"../output/Control.Semigroupoid/index.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Monoid.Additive/index.js":"../output/Data.Monoid.Additive/index.js","../Data.Monoid.Conj/index.js":"../output/Data.Monoid.Conj/index.js","../Data.Monoid.Disj/index.js":"../output/Data.Monoid.Disj/index.js","../Data.Monoid.Dual/index.js":"../output/Data.Monoid.Dual/index.js","../Data.Monoid.Endo/index.js":"../output/Data.Monoid.Endo/index.js","../Data.Monoid.Multiplicative/index.js":"../output/Data.Monoid.Multiplicative/index.js","../Data.Semigroup.First/index.js":"../output/Data.Semigroup.First/index.js","../Data.Semigroup.Last/index.js":"../output/Data.Semigroup.Last/index.js"}],"../output/Data.Foldable/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Control_Alt = require("../Control.Alt/index.js");

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Category = require("../Control.Category/index.js");

var Control_Plus = require("../Control.Plus/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Function = require("../Data.Function/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_HeytingAlgebra = require("../Data.HeytingAlgebra/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Monoid_Conj = require("../Data.Monoid.Conj/index.js");

var Data_Monoid_Disj = require("../Data.Monoid.Disj/index.js");

var Data_Monoid_Dual = require("../Data.Monoid.Dual/index.js");

var Data_Monoid_Endo = require("../Data.Monoid.Endo/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Ordering = require("../Data.Ordering/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Semiring = require("../Data.Semiring/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Foldable = function Foldable(foldMap, foldl, foldr) {
  this.foldMap = foldMap;
  this.foldl = foldl;
  this.foldr = foldr;
};

var foldr = function foldr(dict) {
  return dict.foldr;
};

var indexr = function indexr(dictFoldable) {
  return function (idx) {
    var go = function go(a) {
      return function (cursor) {
        if (cursor.elem instanceof Data_Maybe.Just) {
          return cursor;
        }

        ;
        var $106 = cursor.pos === idx;

        if ($106) {
          return {
            elem: new Data_Maybe.Just(a),
            pos: cursor.pos
          };
        }

        ;
        return {
          pos: cursor.pos + 1 | 0,
          elem: cursor.elem
        };
      };
    };

    var $193 = foldr(dictFoldable)(go)({
      elem: Data_Maybe.Nothing.value,
      pos: 0
    });
    return function ($194) {
      return function (v) {
        return v.elem;
      }($193($194));
    };
  };
};

var $$null = function $$null(dictFoldable) {
  return foldr(dictFoldable)(function (v) {
    return function (v1) {
      return false;
    };
  })(true);
};

var oneOf = function oneOf(dictFoldable) {
  return function (dictPlus) {
    return foldr(dictFoldable)(Control_Alt.alt(dictPlus.Alt0()))(Control_Plus.empty(dictPlus));
  };
};

var oneOfMap = function oneOfMap(dictFoldable) {
  return function (dictPlus) {
    return function (f) {
      return foldr(dictFoldable)(function () {
        var $195 = Control_Alt.alt(dictPlus.Alt0());
        return function ($196) {
          return $195(f($196));
        };
      }())(Control_Plus.empty(dictPlus));
    };
  };
};

var traverse_ = function traverse_(dictApplicative) {
  return function (dictFoldable) {
    return function (f) {
      return foldr(dictFoldable)(function () {
        var $197 = Control_Apply.applySecond(dictApplicative.Apply0());
        return function ($198) {
          return $197(f($198));
        };
      }())(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
    };
  };
};

var for_ = function for_(dictApplicative) {
  return function (dictFoldable) {
    return Data_Function.flip(traverse_(dictApplicative)(dictFoldable));
  };
};

var sequence_ = function sequence_(dictApplicative) {
  return function (dictFoldable) {
    return traverse_(dictApplicative)(dictFoldable)(Control_Category.identity(Control_Category.categoryFn));
  };
};

var foldl = function foldl(dict) {
  return dict.foldl;
};

var indexl = function indexl(dictFoldable) {
  return function (idx) {
    var go = function go(cursor) {
      return function (a) {
        if (cursor.elem instanceof Data_Maybe.Just) {
          return cursor;
        }

        ;
        var $109 = cursor.pos === idx;

        if ($109) {
          return {
            elem: new Data_Maybe.Just(a),
            pos: cursor.pos
          };
        }

        ;
        return {
          pos: cursor.pos + 1 | 0,
          elem: cursor.elem
        };
      };
    };

    var $199 = foldl(dictFoldable)(go)({
      elem: Data_Maybe.Nothing.value,
      pos: 0
    });
    return function ($200) {
      return function (v) {
        return v.elem;
      }($199($200));
    };
  };
};

var intercalate = function intercalate(dictFoldable) {
  return function (dictMonoid) {
    return function (sep) {
      return function (xs) {
        var go = function go(v) {
          return function (x) {
            if (v.init) {
              return {
                init: false,
                acc: x
              };
            }

            ;
            return {
              init: false,
              acc: Data_Semigroup.append(dictMonoid.Semigroup0())(v.acc)(Data_Semigroup.append(dictMonoid.Semigroup0())(sep)(x))
            };
          };
        };

        return foldl(dictFoldable)(go)({
          init: true,
          acc: Data_Monoid.mempty(dictMonoid)
        })(xs).acc;
      };
    };
  };
};

var length = function length(dictFoldable) {
  return function (dictSemiring) {
    return foldl(dictFoldable)(function (c) {
      return function (v) {
        return Data_Semiring.add(dictSemiring)(Data_Semiring.one(dictSemiring))(c);
      };
    })(Data_Semiring.zero(dictSemiring));
  };
};

var maximumBy = function maximumBy(dictFoldable) {
  return function (cmp) {
    var max$prime = function max$prime(v) {
      return function (v1) {
        if (v instanceof Data_Maybe.Nothing) {
          return new Data_Maybe.Just(v1);
        }

        ;

        if (v instanceof Data_Maybe.Just) {
          return new Data_Maybe.Just(function () {
            var $116 = Data_Eq.eq(Data_Ordering.eqOrdering)(cmp(v.value0)(v1))(Data_Ordering.GT.value);

            if ($116) {
              return v.value0;
            }

            ;
            return v1;
          }());
        }

        ;
        throw new Error("Failed pattern match at Data.Foldable (line 389, column 3 - line 389, column 27): " + [v.constructor.name, v1.constructor.name]);
      };
    };

    return foldl(dictFoldable)(max$prime)(Data_Maybe.Nothing.value);
  };
};

var maximum = function maximum(dictOrd) {
  return function (dictFoldable) {
    return maximumBy(dictFoldable)(Data_Ord.compare(dictOrd));
  };
};

var minimumBy = function minimumBy(dictFoldable) {
  return function (cmp) {
    var min$prime = function min$prime(v) {
      return function (v1) {
        if (v instanceof Data_Maybe.Nothing) {
          return new Data_Maybe.Just(v1);
        }

        ;

        if (v instanceof Data_Maybe.Just) {
          return new Data_Maybe.Just(function () {
            var $120 = Data_Eq.eq(Data_Ordering.eqOrdering)(cmp(v.value0)(v1))(Data_Ordering.LT.value);

            if ($120) {
              return v.value0;
            }

            ;
            return v1;
          }());
        }

        ;
        throw new Error("Failed pattern match at Data.Foldable (line 402, column 3 - line 402, column 27): " + [v.constructor.name, v1.constructor.name]);
      };
    };

    return foldl(dictFoldable)(min$prime)(Data_Maybe.Nothing.value);
  };
};

var minimum = function minimum(dictOrd) {
  return function (dictFoldable) {
    return minimumBy(dictFoldable)(Data_Ord.compare(dictOrd));
  };
};

var product = function product(dictFoldable) {
  return function (dictSemiring) {
    return foldl(dictFoldable)(Data_Semiring.mul(dictSemiring))(Data_Semiring.one(dictSemiring));
  };
};

var sum = function sum(dictFoldable) {
  return function (dictSemiring) {
    return foldl(dictFoldable)(Data_Semiring.add(dictSemiring))(Data_Semiring.zero(dictSemiring));
  };
};

var foldableMultiplicative = new Foldable(function (dictMonoid) {
  return function (f) {
    return function (v) {
      return f(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(z)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(v)(z);
    };
  };
});
var foldableMaybe = new Foldable(function (dictMonoid) {
  return function (f) {
    return function (v) {
      if (v instanceof Data_Maybe.Nothing) {
        return Data_Monoid.mempty(dictMonoid);
      }

      ;

      if (v instanceof Data_Maybe.Just) {
        return f(v.value0);
      }

      ;
      throw new Error("Failed pattern match at Data.Foldable (line 129, column 1 - line 135, column 27): " + [f.constructor.name, v.constructor.name]);
    };
  };
}, function (v) {
  return function (z) {
    return function (v1) {
      if (v1 instanceof Data_Maybe.Nothing) {
        return z;
      }

      ;

      if (v1 instanceof Data_Maybe.Just) {
        return v(z)(v1.value0);
      }

      ;
      throw new Error("Failed pattern match at Data.Foldable (line 129, column 1 - line 135, column 27): " + [v.constructor.name, z.constructor.name, v1.constructor.name]);
    };
  };
}, function (v) {
  return function (z) {
    return function (v1) {
      if (v1 instanceof Data_Maybe.Nothing) {
        return z;
      }

      ;

      if (v1 instanceof Data_Maybe.Just) {
        return v(v1.value0)(z);
      }

      ;
      throw new Error("Failed pattern match at Data.Foldable (line 129, column 1 - line 135, column 27): " + [v.constructor.name, z.constructor.name, v1.constructor.name]);
    };
  };
});
var foldableDual = new Foldable(function (dictMonoid) {
  return function (f) {
    return function (v) {
      return f(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(z)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(v)(z);
    };
  };
});
var foldableDisj = new Foldable(function (dictMonoid) {
  return function (f) {
    return function (v) {
      return f(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(z)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(v)(z);
    };
  };
});
var foldableConj = new Foldable(function (dictMonoid) {
  return function (f) {
    return function (v) {
      return f(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(z)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(v)(z);
    };
  };
});
var foldableAdditive = new Foldable(function (dictMonoid) {
  return function (f) {
    return function (v) {
      return f(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(z)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(v)(z);
    };
  };
});

var foldMapDefaultR = function foldMapDefaultR(dictFoldable) {
  return function (dictMonoid) {
    return function (f) {
      return foldr(dictFoldable)(function (x) {
        return function (acc) {
          return Data_Semigroup.append(dictMonoid.Semigroup0())(f(x))(acc);
        };
      })(Data_Monoid.mempty(dictMonoid));
    };
  };
};

var foldableArray = new Foldable(function (dictMonoid) {
  return foldMapDefaultR(foldableArray)(dictMonoid);
}, $foreign.foldlArray, $foreign.foldrArray);

var foldMapDefaultL = function foldMapDefaultL(dictFoldable) {
  return function (dictMonoid) {
    return function (f) {
      return foldl(dictFoldable)(function (acc) {
        return function (x) {
          return Data_Semigroup.append(dictMonoid.Semigroup0())(acc)(f(x));
        };
      })(Data_Monoid.mempty(dictMonoid));
    };
  };
};

var foldMap = function foldMap(dict) {
  return dict.foldMap;
};

var foldableFirst = new Foldable(function (dictMonoid) {
  return function (f) {
    return function (v) {
      return foldMap(foldableMaybe)(dictMonoid)(f)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return foldl(foldableMaybe)(f)(z)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return foldr(foldableMaybe)(f)(z)(v);
    };
  };
});
var foldableLast = new Foldable(function (dictMonoid) {
  return function (f) {
    return function (v) {
      return foldMap(foldableMaybe)(dictMonoid)(f)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return foldl(foldableMaybe)(f)(z)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return foldr(foldableMaybe)(f)(z)(v);
    };
  };
});

var foldlDefault = function foldlDefault(dictFoldable) {
  return function (c) {
    return function (u) {
      return function (xs) {
        return Data_Newtype.unwrap(Data_Newtype.newtypeEndo)(Data_Newtype.unwrap(Data_Newtype.newtypeDual)(foldMap(dictFoldable)(Data_Monoid_Dual.monoidDual(Data_Monoid_Endo.monoidEndo(Control_Category.categoryFn)))(function () {
          var $201 = Data_Function.flip(c);
          return function ($202) {
            return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo($201($202)));
          };
        }())(xs)))(u);
      };
    };
  };
};

var foldrDefault = function foldrDefault(dictFoldable) {
  return function (c) {
    return function (u) {
      return function (xs) {
        return Data_Newtype.unwrap(Data_Newtype.newtypeEndo)(foldMap(dictFoldable)(Data_Monoid_Endo.monoidEndo(Control_Category.categoryFn))(function ($203) {
          return Data_Monoid_Endo.Endo(c($203));
        })(xs))(u);
      };
    };
  };
};

var surroundMap = function surroundMap(dictFoldable) {
  return function (dictSemigroup) {
    return function (d) {
      return function (t) {
        return function (f) {
          var joined = function joined(a) {
            return function (m) {
              return Data_Semigroup.append(dictSemigroup)(d)(Data_Semigroup.append(dictSemigroup)(t(a))(m));
            };
          };

          return Data_Newtype.unwrap(Data_Newtype.newtypeEndo)(foldMap(dictFoldable)(Data_Monoid_Endo.monoidEndo(Control_Category.categoryFn))(joined)(f))(d);
        };
      };
    };
  };
};

var surround = function surround(dictFoldable) {
  return function (dictSemigroup) {
    return function (d) {
      return surroundMap(dictFoldable)(dictSemigroup)(d)(Control_Category.identity(Control_Category.categoryFn));
    };
  };
};

var foldM = function foldM(dictFoldable) {
  return function (dictMonad) {
    return function (f) {
      return function (a0) {
        return foldl(dictFoldable)(function (ma) {
          return function (b) {
            return Control_Bind.bind(dictMonad.Bind1())(ma)(Data_Function.flip(f)(b));
          };
        })(Control_Applicative.pure(dictMonad.Applicative0())(a0));
      };
    };
  };
};

var fold = function fold(dictFoldable) {
  return function (dictMonoid) {
    return foldMap(dictFoldable)(dictMonoid)(Control_Category.identity(Control_Category.categoryFn));
  };
};

var findMap = function findMap(dictFoldable) {
  return function (p) {
    var go = function go(v) {
      return function (v1) {
        if (v instanceof Data_Maybe.Nothing) {
          return p(v1);
        }

        ;
        return v;
      };
    };

    return foldl(dictFoldable)(go)(Data_Maybe.Nothing.value);
  };
};

var find = function find(dictFoldable) {
  return function (p) {
    var go = function go(v) {
      return function (v1) {
        if (v instanceof Data_Maybe.Nothing && p(v1)) {
          return new Data_Maybe.Just(v1);
        }

        ;
        return v;
      };
    };

    return foldl(dictFoldable)(go)(Data_Maybe.Nothing.value);
  };
};

var any = function any(dictFoldable) {
  return function (dictHeytingAlgebra) {
    return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Newtype.newtypeDisj)(Data_Newtype.newtypeDisj)(Data_Monoid_Disj.Disj)(foldMap(dictFoldable)(Data_Monoid_Disj.monoidDisj(dictHeytingAlgebra)));
  };
};

var elem = function elem(dictFoldable) {
  return function (dictEq) {
    var $204 = any(dictFoldable)(Data_HeytingAlgebra.heytingAlgebraBoolean);
    var $205 = Data_Eq.eq(dictEq);
    return function ($206) {
      return $204($205($206));
    };
  };
};

var notElem = function notElem(dictFoldable) {
  return function (dictEq) {
    return function (x) {
      var $207 = Data_HeytingAlgebra.not(Data_HeytingAlgebra.heytingAlgebraBoolean);
      var $208 = elem(dictFoldable)(dictEq)(x);
      return function ($209) {
        return $207($208($209));
      };
    };
  };
};

var or = function or(dictFoldable) {
  return function (dictHeytingAlgebra) {
    return any(dictFoldable)(dictHeytingAlgebra)(Control_Category.identity(Control_Category.categoryFn));
  };
};

var all = function all(dictFoldable) {
  return function (dictHeytingAlgebra) {
    return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Newtype.newtypeConj)(Data_Newtype.newtypeConj)(Data_Monoid_Conj.Conj)(foldMap(dictFoldable)(Data_Monoid_Conj.monoidConj(dictHeytingAlgebra)));
  };
};

var and = function and(dictFoldable) {
  return function (dictHeytingAlgebra) {
    return all(dictFoldable)(dictHeytingAlgebra)(Control_Category.identity(Control_Category.categoryFn));
  };
};

module.exports = {
  Foldable: Foldable,
  foldr: foldr,
  foldl: foldl,
  foldMap: foldMap,
  foldrDefault: foldrDefault,
  foldlDefault: foldlDefault,
  foldMapDefaultL: foldMapDefaultL,
  foldMapDefaultR: foldMapDefaultR,
  fold: fold,
  foldM: foldM,
  traverse_: traverse_,
  for_: for_,
  sequence_: sequence_,
  oneOf: oneOf,
  oneOfMap: oneOfMap,
  intercalate: intercalate,
  surroundMap: surroundMap,
  surround: surround,
  and: and,
  or: or,
  all: all,
  any: any,
  sum: sum,
  product: product,
  elem: elem,
  notElem: notElem,
  indexl: indexl,
  indexr: indexr,
  find: find,
  findMap: findMap,
  maximum: maximum,
  maximumBy: maximumBy,
  minimum: minimum,
  minimumBy: minimumBy,
  "null": $$null,
  length: length,
  foldableArray: foldableArray,
  foldableMaybe: foldableMaybe,
  foldableFirst: foldableFirst,
  foldableLast: foldableLast,
  foldableAdditive: foldableAdditive,
  foldableDual: foldableDual,
  foldableDisj: foldableDisj,
  foldableConj: foldableConj,
  foldableMultiplicative: foldableMultiplicative
};
},{"./foreign.js":"../output/Data.Foldable/foreign.js","../Control.Alt/index.js":"../output/Control.Alt/index.js","../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Control.Plus/index.js":"../output/Control.Plus/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.HeytingAlgebra/index.js":"../output/Data.HeytingAlgebra/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Monoid.Conj/index.js":"../output/Data.Monoid.Conj/index.js","../Data.Monoid.Disj/index.js":"../output/Data.Monoid.Disj/index.js","../Data.Monoid.Dual/index.js":"../output/Data.Monoid.Dual/index.js","../Data.Monoid.Endo/index.js":"../output/Data.Monoid.Endo/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Ordering/index.js":"../output/Data.Ordering/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Semiring/index.js":"../output/Data.Semiring/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Control.Comonad/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Comonad = function Comonad(Extend0, extract) {
  this.Extend0 = Extend0;
  this.extract = extract;
};

var extract = function extract(dict) {
  return dict.extract;
};

module.exports = {
  Comonad: Comonad,
  extract: extract
};
},{}],"../output/Control.MonadPlus/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_MonadZero = require("../Control.MonadZero/index.js");

var MonadPlus = function MonadPlus(MonadZero0) {
  this.MonadZero0 = MonadZero0;
};

var monadPlusArray = new MonadPlus(function () {
  return Control_MonadZero.monadZeroArray;
});
module.exports = {
  MonadPlus: MonadPlus,
  monadPlusArray: monadPlusArray
};
},{"../Control.MonadZero/index.js":"../output/Control.MonadZero/index.js"}],"../output/Data.FunctorWithIndex/foreign.js":[function(require,module,exports) {
"use strict";

exports.mapWithIndexArray = function (f) {
  return function (xs) {
    var l = xs.length;
    var result = Array(l);

    for (var i = 0; i < l; i++) {
      result[i] = f(i)(xs[i]);
    }

    return result;
  };
};
},{}],"../output/Data.Maybe.First/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Alt = require("../Control.Alt/index.js");

var Control_Alternative = require("../Control.Alternative/index.js");

var Control_MonadZero = require("../Control.MonadZero/index.js");

var Control_Plus = require("../Control.Plus/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Show = require("../Data.Show/index.js");

var First = function First(x) {
  return x;
};

var showFirst = function showFirst(dictShow) {
  return new Data_Show.Show(function (v) {
    return "First (" + (Data_Show.show(Data_Maybe.showMaybe(dictShow))(v) + ")");
  });
};

var semigroupFirst = new Data_Semigroup.Semigroup(function (v) {
  return function (v1) {
    if (v instanceof Data_Maybe.Just) {
      return v;
    }

    ;
    return v1;
  };
});

var ordFirst = function ordFirst(dictOrd) {
  return Data_Maybe.ordMaybe(dictOrd);
};

var ord1First = Data_Maybe.ord1Maybe;
var newtypeFirst = new Data_Newtype.Newtype(function (n) {
  return n;
}, First);
var monoidFirst = new Data_Monoid.Monoid(function () {
  return semigroupFirst;
}, Data_Maybe.Nothing.value);
var monadFirst = Data_Maybe.monadMaybe;
var invariantFirst = Data_Maybe.invariantMaybe;
var functorFirst = Data_Maybe.functorMaybe;
var extendFirst = Data_Maybe.extendMaybe;

var eqFirst = function eqFirst(dictEq) {
  return Data_Maybe.eqMaybe(dictEq);
};

var eq1First = Data_Maybe.eq1Maybe;

var boundedFirst = function boundedFirst(dictBounded) {
  return Data_Maybe.boundedMaybe(dictBounded);
};

var bindFirst = Data_Maybe.bindMaybe;
var applyFirst = Data_Maybe.applyMaybe;
var applicativeFirst = Data_Maybe.applicativeMaybe;
var altFirst = new Control_Alt.Alt(function () {
  return functorFirst;
}, Data_Semigroup.append(semigroupFirst));
var plusFirst = new Control_Plus.Plus(function () {
  return altFirst;
}, Data_Monoid.mempty(monoidFirst));
var alternativeFirst = new Control_Alternative.Alternative(function () {
  return applicativeFirst;
}, function () {
  return plusFirst;
});
var monadZeroFirst = new Control_MonadZero.MonadZero(function () {
  return alternativeFirst;
}, function () {
  return monadFirst;
});
module.exports = {
  First: First,
  newtypeFirst: newtypeFirst,
  eqFirst: eqFirst,
  eq1First: eq1First,
  ordFirst: ordFirst,
  ord1First: ord1First,
  boundedFirst: boundedFirst,
  functorFirst: functorFirst,
  invariantFirst: invariantFirst,
  applyFirst: applyFirst,
  applicativeFirst: applicativeFirst,
  bindFirst: bindFirst,
  monadFirst: monadFirst,
  extendFirst: extendFirst,
  showFirst: showFirst,
  semigroupFirst: semigroupFirst,
  monoidFirst: monoidFirst,
  altFirst: altFirst,
  plusFirst: plusFirst,
  alternativeFirst: alternativeFirst,
  monadZeroFirst: monadZeroFirst
};
},{"../Control.Alt/index.js":"../output/Control.Alt/index.js","../Control.Alternative/index.js":"../output/Control.Alternative/index.js","../Control.MonadZero/index.js":"../output/Control.MonadZero/index.js","../Control.Plus/index.js":"../output/Control.Plus/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Maybe.Last/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Alt = require("../Control.Alt/index.js");

var Control_Alternative = require("../Control.Alternative/index.js");

var Control_MonadZero = require("../Control.MonadZero/index.js");

var Control_Plus = require("../Control.Plus/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Show = require("../Data.Show/index.js");

var Last = function Last(x) {
  return x;
};

var showLast = function showLast(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Last " + (Data_Show.show(Data_Maybe.showMaybe(dictShow))(v) + ")");
  });
};

var semigroupLast = new Data_Semigroup.Semigroup(function (v) {
  return function (v1) {
    if (v1 instanceof Data_Maybe.Just) {
      return v1;
    }

    ;

    if (v1 instanceof Data_Maybe.Nothing) {
      return v;
    }

    ;
    throw new Error("Failed pattern match at Data.Maybe.Last (line 52, column 1 - line 54, column 36): " + [v.constructor.name, v1.constructor.name]);
  };
});

var ordLast = function ordLast(dictOrd) {
  return Data_Maybe.ordMaybe(dictOrd);
};

var ord1Last = Data_Maybe.ord1Maybe;
var newtypeLast = new Data_Newtype.Newtype(function (n) {
  return n;
}, Last);
var monoidLast = new Data_Monoid.Monoid(function () {
  return semigroupLast;
}, Data_Maybe.Nothing.value);
var monadLast = Data_Maybe.monadMaybe;
var invariantLast = Data_Maybe.invariantMaybe;
var functorLast = Data_Maybe.functorMaybe;
var extendLast = Data_Maybe.extendMaybe;

var eqLast = function eqLast(dictEq) {
  return Data_Maybe.eqMaybe(dictEq);
};

var eq1Last = Data_Maybe.eq1Maybe;

var boundedLast = function boundedLast(dictBounded) {
  return Data_Maybe.boundedMaybe(dictBounded);
};

var bindLast = Data_Maybe.bindMaybe;
var applyLast = Data_Maybe.applyMaybe;
var applicativeLast = Data_Maybe.applicativeMaybe;
var altLast = new Control_Alt.Alt(function () {
  return functorLast;
}, Data_Semigroup.append(semigroupLast));
var plusLast = new Control_Plus.Plus(function () {
  return altLast;
}, Data_Monoid.mempty(monoidLast));
var alternativeLast = new Control_Alternative.Alternative(function () {
  return applicativeLast;
}, function () {
  return plusLast;
});
var monadZeroLast = new Control_MonadZero.MonadZero(function () {
  return alternativeLast;
}, function () {
  return monadLast;
});
module.exports = {
  Last: Last,
  newtypeLast: newtypeLast,
  eqLast: eqLast,
  eq1Last: eq1Last,
  ordLast: ordLast,
  ord1Last: ord1Last,
  boundedLast: boundedLast,
  functorLast: functorLast,
  invariantLast: invariantLast,
  applyLast: applyLast,
  applicativeLast: applicativeLast,
  bindLast: bindLast,
  monadLast: monadLast,
  extendLast: extendLast,
  showLast: showLast,
  semigroupLast: semigroupLast,
  monoidLast: monoidLast,
  altLast: altLast,
  plusLast: plusLast,
  alternativeLast: alternativeLast,
  monadZeroLast: monadZeroLast
};
},{"../Control.Alt/index.js":"../output/Control.Alt/index.js","../Control.Alternative/index.js":"../output/Control.Alternative/index.js","../Control.MonadZero/index.js":"../output/Control.MonadZero/index.js","../Control.Plus/index.js":"../output/Control.Plus/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.FunctorWithIndex/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Function = require("../Data.Function/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Maybe_First = require("../Data.Maybe.First/index.js");

var Data_Maybe_Last = require("../Data.Maybe.Last/index.js");

var Data_Monoid_Additive = require("../Data.Monoid.Additive/index.js");

var Data_Monoid_Conj = require("../Data.Monoid.Conj/index.js");

var Data_Monoid_Disj = require("../Data.Monoid.Disj/index.js");

var Data_Monoid_Dual = require("../Data.Monoid.Dual/index.js");

var Data_Monoid_Multiplicative = require("../Data.Monoid.Multiplicative/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var FunctorWithIndex = function FunctorWithIndex(Functor0, mapWithIndex) {
  this.Functor0 = Functor0;
  this.mapWithIndex = mapWithIndex;
};

var mapWithIndex = function mapWithIndex(dict) {
  return dict.mapWithIndex;
};

var mapDefault = function mapDefault(dictFunctorWithIndex) {
  return function (f) {
    return mapWithIndex(dictFunctorWithIndex)(Data_Function["const"](f));
  };
};

var functorWithIndexMultiplicative = new FunctorWithIndex(function () {
  return Data_Monoid_Multiplicative.functorMultiplicative;
}, function (f) {
  return Data_Functor.map(Data_Monoid_Multiplicative.functorMultiplicative)(f(Data_Unit.unit));
});
var functorWithIndexMaybe = new FunctorWithIndex(function () {
  return Data_Maybe.functorMaybe;
}, function (f) {
  return Data_Functor.map(Data_Maybe.functorMaybe)(f(Data_Unit.unit));
});
var functorWithIndexLast = new FunctorWithIndex(function () {
  return Data_Maybe_Last.functorLast;
}, function (f) {
  return Data_Functor.map(Data_Maybe_Last.functorLast)(f(Data_Unit.unit));
});
var functorWithIndexFirst = new FunctorWithIndex(function () {
  return Data_Maybe_First.functorFirst;
}, function (f) {
  return Data_Functor.map(Data_Maybe_First.functorFirst)(f(Data_Unit.unit));
});
var functorWithIndexDual = new FunctorWithIndex(function () {
  return Data_Monoid_Dual.functorDual;
}, function (f) {
  return Data_Functor.map(Data_Monoid_Dual.functorDual)(f(Data_Unit.unit));
});
var functorWithIndexDisj = new FunctorWithIndex(function () {
  return Data_Monoid_Disj.functorDisj;
}, function (f) {
  return Data_Functor.map(Data_Monoid_Disj.functorDisj)(f(Data_Unit.unit));
});
var functorWithIndexConj = new FunctorWithIndex(function () {
  return Data_Monoid_Conj.functorConj;
}, function (f) {
  return Data_Functor.map(Data_Monoid_Conj.functorConj)(f(Data_Unit.unit));
});
var functorWithIndexArray = new FunctorWithIndex(function () {
  return Data_Functor.functorArray;
}, $foreign.mapWithIndexArray);
var functorWithIndexAdditive = new FunctorWithIndex(function () {
  return Data_Monoid_Additive.functorAdditive;
}, function (f) {
  return Data_Functor.map(Data_Monoid_Additive.functorAdditive)(f(Data_Unit.unit));
});
module.exports = {
  FunctorWithIndex: FunctorWithIndex,
  mapWithIndex: mapWithIndex,
  mapDefault: mapDefault,
  functorWithIndexArray: functorWithIndexArray,
  functorWithIndexMaybe: functorWithIndexMaybe,
  functorWithIndexFirst: functorWithIndexFirst,
  functorWithIndexLast: functorWithIndexLast,
  functorWithIndexAdditive: functorWithIndexAdditive,
  functorWithIndexDual: functorWithIndexDual,
  functorWithIndexConj: functorWithIndexConj,
  functorWithIndexDisj: functorWithIndexDisj,
  functorWithIndexMultiplicative: functorWithIndexMultiplicative
};
},{"./foreign.js":"../output/Data.FunctorWithIndex/foreign.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Maybe.First/index.js":"../output/Data.Maybe.First/index.js","../Data.Maybe.Last/index.js":"../output/Data.Maybe.Last/index.js","../Data.Monoid.Additive/index.js":"../output/Data.Monoid.Additive/index.js","../Data.Monoid.Conj/index.js":"../output/Data.Monoid.Conj/index.js","../Data.Monoid.Disj/index.js":"../output/Data.Monoid.Disj/index.js","../Data.Monoid.Dual/index.js":"../output/Data.Monoid.Dual/index.js","../Data.Monoid.Multiplicative/index.js":"../output/Data.Monoid.Multiplicative/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.FoldableWithIndex/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Category = require("../Control.Category/index.js");

var Data_Foldable = require("../Data.Foldable/index.js");

var Data_Function = require("../Data.Function/index.js");

var Data_FunctorWithIndex = require("../Data.FunctorWithIndex/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Monoid_Conj = require("../Data.Monoid.Conj/index.js");

var Data_Monoid_Disj = require("../Data.Monoid.Disj/index.js");

var Data_Monoid_Dual = require("../Data.Monoid.Dual/index.js");

var Data_Monoid_Endo = require("../Data.Monoid.Endo/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Tuple = function () {
  function Tuple(value0, value1) {
    this.value0 = value0;
    this.value1 = value1;
  }

  ;

  Tuple.create = function (value0) {
    return function (value1) {
      return new Tuple(value0, value1);
    };
  };

  return Tuple;
}();

var FoldableWithIndex = function FoldableWithIndex(Foldable0, foldMapWithIndex, foldlWithIndex, foldrWithIndex) {
  this.Foldable0 = Foldable0;
  this.foldMapWithIndex = foldMapWithIndex;
  this.foldlWithIndex = foldlWithIndex;
  this.foldrWithIndex = foldrWithIndex;
};

var foldrWithIndex = function foldrWithIndex(dict) {
  return dict.foldrWithIndex;
};

var traverseWithIndex_ = function traverseWithIndex_(dictApplicative) {
  return function (dictFoldableWithIndex) {
    return function (f) {
      return foldrWithIndex(dictFoldableWithIndex)(function (i) {
        var $46 = Control_Apply.applySecond(dictApplicative.Apply0());
        var $47 = f(i);
        return function ($48) {
          return $46($47($48));
        };
      })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
    };
  };
};

var forWithIndex_ = function forWithIndex_(dictApplicative) {
  return function (dictFoldableWithIndex) {
    return Data_Function.flip(traverseWithIndex_(dictApplicative)(dictFoldableWithIndex));
  };
};

var foldrDefault = function foldrDefault(dictFoldableWithIndex) {
  return function (f) {
    return foldrWithIndex(dictFoldableWithIndex)(Data_Function["const"](f));
  };
};

var foldlWithIndex = function foldlWithIndex(dict) {
  return dict.foldlWithIndex;
};

var foldlDefault = function foldlDefault(dictFoldableWithIndex) {
  return function (f) {
    return foldlWithIndex(dictFoldableWithIndex)(Data_Function["const"](f));
  };
};

var foldableWithIndexMultiplicative = new FoldableWithIndex(function () {
  return Data_Foldable.foldableMultiplicative;
}, function (dictMonoid) {
  return function (f) {
    return Data_Foldable.foldMap(Data_Foldable.foldableMultiplicative)(dictMonoid)(f(Data_Unit.unit));
  };
}, function (f) {
  return Data_Foldable.foldl(Data_Foldable.foldableMultiplicative)(f(Data_Unit.unit));
}, function (f) {
  return Data_Foldable.foldr(Data_Foldable.foldableMultiplicative)(f(Data_Unit.unit));
});
var foldableWithIndexMaybe = new FoldableWithIndex(function () {
  return Data_Foldable.foldableMaybe;
}, function (dictMonoid) {
  return function (f) {
    return Data_Foldable.foldMap(Data_Foldable.foldableMaybe)(dictMonoid)(f(Data_Unit.unit));
  };
}, function (f) {
  return Data_Foldable.foldl(Data_Foldable.foldableMaybe)(f(Data_Unit.unit));
}, function (f) {
  return Data_Foldable.foldr(Data_Foldable.foldableMaybe)(f(Data_Unit.unit));
});
var foldableWithIndexLast = new FoldableWithIndex(function () {
  return Data_Foldable.foldableLast;
}, function (dictMonoid) {
  return function (f) {
    return Data_Foldable.foldMap(Data_Foldable.foldableLast)(dictMonoid)(f(Data_Unit.unit));
  };
}, function (f) {
  return Data_Foldable.foldl(Data_Foldable.foldableLast)(f(Data_Unit.unit));
}, function (f) {
  return Data_Foldable.foldr(Data_Foldable.foldableLast)(f(Data_Unit.unit));
});
var foldableWithIndexFirst = new FoldableWithIndex(function () {
  return Data_Foldable.foldableFirst;
}, function (dictMonoid) {
  return function (f) {
    return Data_Foldable.foldMap(Data_Foldable.foldableFirst)(dictMonoid)(f(Data_Unit.unit));
  };
}, function (f) {
  return Data_Foldable.foldl(Data_Foldable.foldableFirst)(f(Data_Unit.unit));
}, function (f) {
  return Data_Foldable.foldr(Data_Foldable.foldableFirst)(f(Data_Unit.unit));
});
var foldableWithIndexDual = new FoldableWithIndex(function () {
  return Data_Foldable.foldableDual;
}, function (dictMonoid) {
  return function (f) {
    return Data_Foldable.foldMap(Data_Foldable.foldableDual)(dictMonoid)(f(Data_Unit.unit));
  };
}, function (f) {
  return Data_Foldable.foldl(Data_Foldable.foldableDual)(f(Data_Unit.unit));
}, function (f) {
  return Data_Foldable.foldr(Data_Foldable.foldableDual)(f(Data_Unit.unit));
});
var foldableWithIndexDisj = new FoldableWithIndex(function () {
  return Data_Foldable.foldableDisj;
}, function (dictMonoid) {
  return function (f) {
    return Data_Foldable.foldMap(Data_Foldable.foldableDisj)(dictMonoid)(f(Data_Unit.unit));
  };
}, function (f) {
  return Data_Foldable.foldl(Data_Foldable.foldableDisj)(f(Data_Unit.unit));
}, function (f) {
  return Data_Foldable.foldr(Data_Foldable.foldableDisj)(f(Data_Unit.unit));
});
var foldableWithIndexConj = new FoldableWithIndex(function () {
  return Data_Foldable.foldableConj;
}, function (dictMonoid) {
  return function (f) {
    return Data_Foldable.foldMap(Data_Foldable.foldableConj)(dictMonoid)(f(Data_Unit.unit));
  };
}, function (f) {
  return Data_Foldable.foldl(Data_Foldable.foldableConj)(f(Data_Unit.unit));
}, function (f) {
  return Data_Foldable.foldr(Data_Foldable.foldableConj)(f(Data_Unit.unit));
});
var foldableWithIndexAdditive = new FoldableWithIndex(function () {
  return Data_Foldable.foldableAdditive;
}, function (dictMonoid) {
  return function (f) {
    return Data_Foldable.foldMap(Data_Foldable.foldableAdditive)(dictMonoid)(f(Data_Unit.unit));
  };
}, function (f) {
  return Data_Foldable.foldl(Data_Foldable.foldableAdditive)(f(Data_Unit.unit));
}, function (f) {
  return Data_Foldable.foldr(Data_Foldable.foldableAdditive)(f(Data_Unit.unit));
});

var foldWithIndexM = function foldWithIndexM(dictFoldableWithIndex) {
  return function (dictMonad) {
    return function (f) {
      return function (a0) {
        return foldlWithIndex(dictFoldableWithIndex)(function (i) {
          return function (ma) {
            return function (b) {
              return Control_Bind.bind(dictMonad.Bind1())(ma)(Data_Function.flip(f(i))(b));
            };
          };
        })(Control_Applicative.pure(dictMonad.Applicative0())(a0));
      };
    };
  };
};

var foldMapWithIndexDefaultR = function foldMapWithIndexDefaultR(dictFoldableWithIndex) {
  return function (dictMonoid) {
    return function (f) {
      return foldrWithIndex(dictFoldableWithIndex)(function (i) {
        return function (x) {
          return function (acc) {
            return Data_Semigroup.append(dictMonoid.Semigroup0())(f(i)(x))(acc);
          };
        };
      })(Data_Monoid.mempty(dictMonoid));
    };
  };
};

var foldableWithIndexArray = new FoldableWithIndex(function () {
  return Data_Foldable.foldableArray;
}, function (dictMonoid) {
  return foldMapWithIndexDefaultR(foldableWithIndexArray)(dictMonoid);
}, function (f) {
  return function (z) {
    var $49 = Data_Foldable.foldl(Data_Foldable.foldableArray)(function (y) {
      return function (v) {
        return f(v.value0)(y)(v.value1);
      };
    })(z);
    var $50 = Data_FunctorWithIndex.mapWithIndex(Data_FunctorWithIndex.functorWithIndexArray)(Tuple.create);
    return function ($51) {
      return $49($50($51));
    };
  };
}, function (f) {
  return function (z) {
    var $52 = Data_Foldable.foldr(Data_Foldable.foldableArray)(function (v) {
      return function (y) {
        return f(v.value0)(v.value1)(y);
      };
    })(z);
    var $53 = Data_FunctorWithIndex.mapWithIndex(Data_FunctorWithIndex.functorWithIndexArray)(Tuple.create);
    return function ($54) {
      return $52($53($54));
    };
  };
});

var foldMapWithIndexDefaultL = function foldMapWithIndexDefaultL(dictFoldableWithIndex) {
  return function (dictMonoid) {
    return function (f) {
      return foldlWithIndex(dictFoldableWithIndex)(function (i) {
        return function (acc) {
          return function (x) {
            return Data_Semigroup.append(dictMonoid.Semigroup0())(acc)(f(i)(x));
          };
        };
      })(Data_Monoid.mempty(dictMonoid));
    };
  };
};

var foldMapWithIndex = function foldMapWithIndex(dict) {
  return dict.foldMapWithIndex;
};

var foldlWithIndexDefault = function foldlWithIndexDefault(dictFoldableWithIndex) {
  return function (c) {
    return function (u) {
      return function (xs) {
        return Data_Newtype.unwrap(Data_Newtype.newtypeEndo)(Data_Newtype.unwrap(Data_Newtype.newtypeDual)(foldMapWithIndex(dictFoldableWithIndex)(Data_Monoid_Dual.monoidDual(Data_Monoid_Endo.monoidEndo(Control_Category.categoryFn)))(function (i) {
          var $55 = Data_Function.flip(c(i));
          return function ($56) {
            return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo($55($56)));
          };
        })(xs)))(u);
      };
    };
  };
};

var foldrWithIndexDefault = function foldrWithIndexDefault(dictFoldableWithIndex) {
  return function (c) {
    return function (u) {
      return function (xs) {
        return Data_Newtype.unwrap(Data_Newtype.newtypeEndo)(foldMapWithIndex(dictFoldableWithIndex)(Data_Monoid_Endo.monoidEndo(Control_Category.categoryFn))(function (i) {
          var $57 = c(i);
          return function ($58) {
            return Data_Monoid_Endo.Endo($57($58));
          };
        })(xs))(u);
      };
    };
  };
};

var surroundMapWithIndex = function surroundMapWithIndex(dictFoldableWithIndex) {
  return function (dictSemigroup) {
    return function (d) {
      return function (t) {
        return function (f) {
          var joined = function joined(i) {
            return function (a) {
              return function (m) {
                return Data_Semigroup.append(dictSemigroup)(d)(Data_Semigroup.append(dictSemigroup)(t(i)(a))(m));
              };
            };
          };

          return Data_Newtype.unwrap(Data_Newtype.newtypeEndo)(foldMapWithIndex(dictFoldableWithIndex)(Data_Monoid_Endo.monoidEndo(Control_Category.categoryFn))(joined)(f))(d);
        };
      };
    };
  };
};

var foldMapDefault = function foldMapDefault(dictFoldableWithIndex) {
  return function (dictMonoid) {
    return function (f) {
      return foldMapWithIndex(dictFoldableWithIndex)(dictMonoid)(Data_Function["const"](f));
    };
  };
};

var findWithIndex = function findWithIndex(dictFoldableWithIndex) {
  return function (p) {
    var go = function go(v) {
      return function (v1) {
        return function (v2) {
          if (v1 instanceof Data_Maybe.Nothing && p(v)(v2)) {
            return new Data_Maybe.Just({
              index: v,
              value: v2
            });
          }

          ;
          return v1;
        };
      };
    };

    return foldlWithIndex(dictFoldableWithIndex)(go)(Data_Maybe.Nothing.value);
  };
};

var anyWithIndex = function anyWithIndex(dictFoldableWithIndex) {
  return function (dictHeytingAlgebra) {
    return function (t) {
      var $59 = Data_Newtype.unwrap(Data_Newtype.newtypeDisj);
      var $60 = foldMapWithIndex(dictFoldableWithIndex)(Data_Monoid_Disj.monoidDisj(dictHeytingAlgebra))(function (i) {
        var $62 = t(i);
        return function ($63) {
          return Data_Monoid_Disj.Disj($62($63));
        };
      });
      return function ($61) {
        return $59($60($61));
      };
    };
  };
};

var allWithIndex = function allWithIndex(dictFoldableWithIndex) {
  return function (dictHeytingAlgebra) {
    return function (t) {
      var $64 = Data_Newtype.unwrap(Data_Newtype.newtypeConj);
      var $65 = foldMapWithIndex(dictFoldableWithIndex)(Data_Monoid_Conj.monoidConj(dictHeytingAlgebra))(function (i) {
        var $67 = t(i);
        return function ($68) {
          return Data_Monoid_Conj.Conj($67($68));
        };
      });
      return function ($66) {
        return $64($65($66));
      };
    };
  };
};

module.exports = {
  FoldableWithIndex: FoldableWithIndex,
  foldrWithIndex: foldrWithIndex,
  foldlWithIndex: foldlWithIndex,
  foldMapWithIndex: foldMapWithIndex,
  foldrWithIndexDefault: foldrWithIndexDefault,
  foldlWithIndexDefault: foldlWithIndexDefault,
  foldMapWithIndexDefaultR: foldMapWithIndexDefaultR,
  foldMapWithIndexDefaultL: foldMapWithIndexDefaultL,
  foldWithIndexM: foldWithIndexM,
  traverseWithIndex_: traverseWithIndex_,
  forWithIndex_: forWithIndex_,
  surroundMapWithIndex: surroundMapWithIndex,
  allWithIndex: allWithIndex,
  anyWithIndex: anyWithIndex,
  findWithIndex: findWithIndex,
  foldrDefault: foldrDefault,
  foldlDefault: foldlDefault,
  foldMapDefault: foldMapDefault,
  foldableWithIndexArray: foldableWithIndexArray,
  foldableWithIndexMaybe: foldableWithIndexMaybe,
  foldableWithIndexFirst: foldableWithIndexFirst,
  foldableWithIndexLast: foldableWithIndexLast,
  foldableWithIndexAdditive: foldableWithIndexAdditive,
  foldableWithIndexDual: foldableWithIndexDual,
  foldableWithIndexDisj: foldableWithIndexDisj,
  foldableWithIndexConj: foldableWithIndexConj,
  foldableWithIndexMultiplicative: foldableWithIndexMultiplicative
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Foldable/index.js":"../output/Data.Foldable/index.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.FunctorWithIndex/index.js":"../output/Data.FunctorWithIndex/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Monoid.Conj/index.js":"../output/Data.Monoid.Conj/index.js","../Data.Monoid.Disj/index.js":"../output/Data.Monoid.Disj/index.js","../Data.Monoid.Dual/index.js":"../output/Data.Monoid.Dual/index.js","../Data.Monoid.Endo/index.js":"../output/Data.Monoid.Endo/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.Ord.Max/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_Bounded = require("../Data.Bounded/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Show = require("../Data.Show/index.js");

var Max = function Max(x) {
  return x;
};

var showMax = function showMax(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Max " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semigroupMax = function semigroupMax(dictOrd) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      return Data_Ord.max(dictOrd)(v)(v1);
    };
  });
};

var newtypeMax = new Data_Newtype.Newtype(function (n) {
  return n;
}, Max);

var monoidMax = function monoidMax(dictBounded) {
  return new Data_Monoid.Monoid(function () {
    return semigroupMax(dictBounded.Ord0());
  }, Data_Bounded.bottom(dictBounded));
};

var eqMax = function eqMax(dictEq) {
  return dictEq;
};

var ordMax = function ordMax(dictOrd) {
  return new Data_Ord.Ord(function () {
    return eqMax(dictOrd.Eq0());
  }, function (v) {
    return function (v1) {
      return Data_Ord.compare(dictOrd)(v)(v1);
    };
  });
};

module.exports = {
  Max: Max,
  newtypeMax: newtypeMax,
  eqMax: eqMax,
  ordMax: ordMax,
  semigroupMax: semigroupMax,
  monoidMax: monoidMax,
  showMax: showMax
};
},{"../Data.Bounded/index.js":"../output/Data.Bounded/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Ord.Min/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_Bounded = require("../Data.Bounded/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Show = require("../Data.Show/index.js");

var Min = function Min(x) {
  return x;
};

var showMin = function showMin(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Min " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semigroupMin = function semigroupMin(dictOrd) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      return Data_Ord.min(dictOrd)(v)(v1);
    };
  });
};

var newtypeMin = new Data_Newtype.Newtype(function (n) {
  return n;
}, Min);

var monoidMin = function monoidMin(dictBounded) {
  return new Data_Monoid.Monoid(function () {
    return semigroupMin(dictBounded.Ord0());
  }, Data_Bounded.top(dictBounded));
};

var eqMin = function eqMin(dictEq) {
  return dictEq;
};

var ordMin = function ordMin(dictOrd) {
  return new Data_Ord.Ord(function () {
    return eqMin(dictOrd.Eq0());
  }, function (v) {
    return function (v1) {
      return Data_Ord.compare(dictOrd)(v)(v1);
    };
  });
};

module.exports = {
  Min: Min,
  newtypeMin: newtypeMin,
  eqMin: eqMin,
  ordMin: ordMin,
  semigroupMin: semigroupMin,
  monoidMin: monoidMin,
  showMin: showMin
};
},{"../Data.Bounded/index.js":"../output/Data.Bounded/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Semigroup.Foldable/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Apply = require("../Control.Apply/index.js");

var Control_Category = require("../Control.Category/index.js");

var Data_Foldable = require("../Data.Foldable/index.js");

var Data_Function = require("../Data.Function/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Ord_Max = require("../Data.Ord.Max/index.js");

var Data_Ord_Min = require("../Data.Ord.Min/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var JoinWith = function JoinWith(x) {
  return x;
};

var Act = function Act(x) {
  return x;
};

var Foldable1 = function Foldable1(Foldable0, fold1, foldMap1) {
  this.Foldable0 = Foldable0;
  this.fold1 = fold1;
  this.foldMap1 = foldMap1;
};

var semigroupJoinWith = function semigroupJoinWith(dictSemigroup) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      return JoinWith(function (j) {
        return Data_Semigroup.append(dictSemigroup)(v(j))(Data_Semigroup.append(dictSemigroup)(j)(v1(j)));
      });
    };
  });
};

var semigroupAct = function semigroupAct(dictApply) {
  return new Data_Semigroup.Semigroup(function (v) {
    return function (v1) {
      return Control_Apply.applySecond(dictApply)(v)(v1);
    };
  });
};

var joinee = function joinee(v) {
  return v;
};

var getAct = function getAct(v) {
  return v;
};

var foldMap1 = function foldMap1(dict) {
  return dict.foldMap1;
};

var intercalateMap = function intercalateMap(dictFoldable1) {
  return function (dictSemigroup) {
    return function (j) {
      return function (f) {
        return function (foldable) {
          return joinee(foldMap1(dictFoldable1)(semigroupJoinWith(dictSemigroup))(function ($43) {
            return JoinWith(Data_Function["const"](f($43)));
          })(foldable))(j);
        };
      };
    };
  };
};

var intercalate = function intercalate(dictFoldable1) {
  return function (dictSemigroup) {
    return Data_Function.flip(intercalateMap(dictFoldable1)(dictSemigroup))(Control_Category.identity(Control_Category.categoryFn));
  };
};

var maximum = function maximum(dictOrd) {
  return function (dictFoldable1) {
    return Data_Newtype.ala(Data_Functor.functorFn)(Data_Ord_Max.newtypeMax)(Data_Ord_Max.newtypeMax)(Data_Ord_Max.Max)(foldMap1(dictFoldable1)(Data_Ord_Max.semigroupMax(dictOrd)));
  };
};

var minimum = function minimum(dictOrd) {
  return function (dictFoldable1) {
    return Data_Newtype.ala(Data_Functor.functorFn)(Data_Ord_Min.newtypeMin)(Data_Ord_Min.newtypeMin)(Data_Ord_Min.Min)(foldMap1(dictFoldable1)(Data_Ord_Min.semigroupMin(dictOrd)));
  };
};

var traverse1_ = function traverse1_(dictFoldable1) {
  return function (dictApply) {
    return function (f) {
      return function (t) {
        return Data_Functor.voidRight(dictApply.Functor0())(Data_Unit.unit)(getAct(foldMap1(dictFoldable1)(semigroupAct(dictApply))(function ($44) {
          return Act(f($44));
        })(t)));
      };
    };
  };
};

var for1_ = function for1_(dictFoldable1) {
  return function (dictApply) {
    return Data_Function.flip(traverse1_(dictFoldable1)(dictApply));
  };
};

var sequence1_ = function sequence1_(dictFoldable1) {
  return function (dictApply) {
    return traverse1_(dictFoldable1)(dictApply)(Control_Category.identity(Control_Category.categoryFn));
  };
};

var fold1Default = function fold1Default(dictFoldable1) {
  return function (dictSemigroup) {
    return foldMap1(dictFoldable1)(dictSemigroup)(Control_Category.identity(Control_Category.categoryFn));
  };
};

var foldableDual = new Foldable1(function () {
  return Data_Foldable.foldableDual;
}, function (dictSemigroup) {
  return fold1Default(foldableDual)(dictSemigroup);
}, function (dictSemigroup) {
  return function (f) {
    return function (v) {
      return f(v);
    };
  };
});
var foldableMultiplicative = new Foldable1(function () {
  return Data_Foldable.foldableMultiplicative;
}, function (dictSemigroup) {
  return fold1Default(foldableMultiplicative)(dictSemigroup);
}, function (dictSemigroup) {
  return function (f) {
    return function (v) {
      return f(v);
    };
  };
});

var fold1 = function fold1(dict) {
  return dict.fold1;
};

var foldMap1Default = function foldMap1Default(dictFoldable1) {
  return function (dictFunctor) {
    return function (dictSemigroup) {
      return function (f) {
        var $45 = fold1(dictFoldable1)(dictSemigroup);
        var $46 = Data_Functor.map(dictFunctor)(f);
        return function ($47) {
          return $45($46($47));
        };
      };
    };
  };
};

module.exports = {
  Foldable1: Foldable1,
  foldMap1: foldMap1,
  fold1: fold1,
  traverse1_: traverse1_,
  for1_: for1_,
  sequence1_: sequence1_,
  foldMap1Default: foldMap1Default,
  fold1Default: fold1Default,
  intercalate: intercalate,
  intercalateMap: intercalateMap,
  maximum: maximum,
  minimum: minimum,
  foldableDual: foldableDual,
  foldableMultiplicative: foldableMultiplicative
};
},{"../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Foldable/index.js":"../output/Data.Foldable/index.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Ord.Max/index.js":"../output/Data.Ord.Max/index.js","../Data.Ord.Min/index.js":"../output/Data.Ord.Min/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.Traversable/foreign.js":[function(require,module,exports) {
"use strict"; // jshint maxparams: 3

exports.traverseArrayImpl = function () {
  function array1(a) {
    return [a];
  }

  function array2(a) {
    return function (b) {
      return [a, b];
    };
  }

  function array3(a) {
    return function (b) {
      return function (c) {
        return [a, b, c];
      };
    };
  }

  function concat2(xs) {
    return function (ys) {
      return xs.concat(ys);
    };
  }

  return function (apply) {
    return function (map) {
      return function (pure) {
        return function (f) {
          return function (array) {
            function go(bot, top) {
              switch (top - bot) {
                case 0:
                  return pure([]);

                case 1:
                  return map(array1)(f(array[bot]));

                case 2:
                  return apply(map(array2)(f(array[bot])))(f(array[bot + 1]));

                case 3:
                  return apply(apply(map(array3)(f(array[bot])))(f(array[bot + 1])))(f(array[bot + 2]));

                default:
                  // This slightly tricky pivot selection aims to produce two
                  // even-length partitions where possible.
                  var pivot = bot + Math.floor((top - bot) / 4) * 2;
                  return apply(map(concat2)(go(bot, pivot)))(go(pivot, top));
              }
            }

            return go(0, array.length);
          };
        };
      };
    };
  };
}();
},{}],"../output/Data.Traversable.Accum.Internal/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var StateR = function StateR(x) {
  return x;
};

var StateL = function StateL(x) {
  return x;
};

var stateR = function stateR(v) {
  return v;
};

var stateL = function stateL(v) {
  return v;
};

var functorStateR = new Data_Functor.Functor(function (f) {
  return function (k) {
    return function (s) {
      var v = stateR(k)(s);
      return {
        accum: v.accum,
        value: f(v.value)
      };
    };
  };
});
var functorStateL = new Data_Functor.Functor(function (f) {
  return function (k) {
    return function (s) {
      var v = stateL(k)(s);
      return {
        accum: v.accum,
        value: f(v.value)
      };
    };
  };
});
var applyStateR = new Control_Apply.Apply(function () {
  return functorStateR;
}, function (f) {
  return function (x) {
    return function (s) {
      var v = stateR(x)(s);
      var v1 = stateR(f)(v.accum);
      return {
        accum: v1.accum,
        value: v1.value(v.value)
      };
    };
  };
});
var applyStateL = new Control_Apply.Apply(function () {
  return functorStateL;
}, function (f) {
  return function (x) {
    return function (s) {
      var v = stateL(f)(s);
      var v1 = stateL(x)(v.accum);
      return {
        accum: v1.accum,
        value: v.value(v1.value)
      };
    };
  };
});
var applicativeStateR = new Control_Applicative.Applicative(function () {
  return applyStateR;
}, function (a) {
  return function (s) {
    return {
      accum: s,
      value: a
    };
  };
});
var applicativeStateL = new Control_Applicative.Applicative(function () {
  return applyStateL;
}, function (a) {
  return function (s) {
    return {
      accum: s,
      value: a
    };
  };
});
module.exports = {
  StateL: StateL,
  stateL: stateL,
  StateR: StateR,
  stateR: stateR,
  functorStateL: functorStateL,
  applyStateL: applyStateL,
  applicativeStateL: applicativeStateL,
  functorStateR: functorStateR,
  applyStateR: applyStateR,
  applicativeStateR: applicativeStateR
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js"}],"../output/Data.Traversable/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Category = require("../Control.Category/index.js");

var Data_Foldable = require("../Data.Foldable/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Maybe_First = require("../Data.Maybe.First/index.js");

var Data_Maybe_Last = require("../Data.Maybe.Last/index.js");

var Data_Monoid_Additive = require("../Data.Monoid.Additive/index.js");

var Data_Monoid_Conj = require("../Data.Monoid.Conj/index.js");

var Data_Monoid_Disj = require("../Data.Monoid.Disj/index.js");

var Data_Monoid_Dual = require("../Data.Monoid.Dual/index.js");

var Data_Monoid_Multiplicative = require("../Data.Monoid.Multiplicative/index.js");

var Data_Traversable_Accum_Internal = require("../Data.Traversable.Accum.Internal/index.js");

var Traversable = function Traversable(Foldable1, Functor0, sequence, traverse) {
  this.Foldable1 = Foldable1;
  this.Functor0 = Functor0;
  this.sequence = sequence;
  this.traverse = traverse;
};

var traverse = function traverse(dict) {
  return dict.traverse;
};

var traversableMultiplicative = new Traversable(function () {
  return Data_Foldable.foldableMultiplicative;
}, function () {
  return Data_Monoid_Multiplicative.functorMultiplicative;
}, function (dictApplicative) {
  return function (v) {
    return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Monoid_Multiplicative.Multiplicative)(v);
  };
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Monoid_Multiplicative.Multiplicative)(f(v));
    };
  };
});
var traversableMaybe = new Traversable(function () {
  return Data_Foldable.foldableMaybe;
}, function () {
  return Data_Maybe.functorMaybe;
}, function (dictApplicative) {
  return function (v) {
    if (v instanceof Data_Maybe.Nothing) {
      return Control_Applicative.pure(dictApplicative)(Data_Maybe.Nothing.value);
    }

    ;

    if (v instanceof Data_Maybe.Just) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Maybe.Just.create)(v.value0);
    }

    ;
    throw new Error("Failed pattern match at Data.Traversable (line 86, column 1 - line 90, column 33): " + [v.constructor.name]);
  };
}, function (dictApplicative) {
  return function (v) {
    return function (v1) {
      if (v1 instanceof Data_Maybe.Nothing) {
        return Control_Applicative.pure(dictApplicative)(Data_Maybe.Nothing.value);
      }

      ;

      if (v1 instanceof Data_Maybe.Just) {
        return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Maybe.Just.create)(v(v1.value0));
      }

      ;
      throw new Error("Failed pattern match at Data.Traversable (line 86, column 1 - line 90, column 33): " + [v.constructor.name, v1.constructor.name]);
    };
  };
});
var traversableDual = new Traversable(function () {
  return Data_Foldable.foldableDual;
}, function () {
  return Data_Monoid_Dual.functorDual;
}, function (dictApplicative) {
  return function (v) {
    return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Monoid_Dual.Dual)(v);
  };
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Monoid_Dual.Dual)(f(v));
    };
  };
});
var traversableDisj = new Traversable(function () {
  return Data_Foldable.foldableDisj;
}, function () {
  return Data_Monoid_Disj.functorDisj;
}, function (dictApplicative) {
  return function (v) {
    return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Monoid_Disj.Disj)(v);
  };
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Monoid_Disj.Disj)(f(v));
    };
  };
});
var traversableConj = new Traversable(function () {
  return Data_Foldable.foldableConj;
}, function () {
  return Data_Monoid_Conj.functorConj;
}, function (dictApplicative) {
  return function (v) {
    return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Monoid_Conj.Conj)(v);
  };
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Monoid_Conj.Conj)(f(v));
    };
  };
});
var traversableAdditive = new Traversable(function () {
  return Data_Foldable.foldableAdditive;
}, function () {
  return Data_Monoid_Additive.functorAdditive;
}, function (dictApplicative) {
  return function (v) {
    return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Monoid_Additive.Additive)(v);
  };
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Monoid_Additive.Additive)(f(v));
    };
  };
});

var sequenceDefault = function sequenceDefault(dictTraversable) {
  return function (dictApplicative) {
    return traverse(dictTraversable)(dictApplicative)(Control_Category.identity(Control_Category.categoryFn));
  };
};

var traversableArray = new Traversable(function () {
  return Data_Foldable.foldableArray;
}, function () {
  return Data_Functor.functorArray;
}, function (dictApplicative) {
  return sequenceDefault(traversableArray)(dictApplicative);
}, function (dictApplicative) {
  return $foreign.traverseArrayImpl(Control_Apply.apply(dictApplicative.Apply0()))(Data_Functor.map(dictApplicative.Apply0().Functor0()))(Control_Applicative.pure(dictApplicative));
});

var sequence = function sequence(dict) {
  return dict.sequence;
};

var traversableFirst = new Traversable(function () {
  return Data_Foldable.foldableFirst;
}, function () {
  return Data_Maybe_First.functorFirst;
}, function (dictApplicative) {
  return function (v) {
    return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Maybe_First.First)(sequence(traversableMaybe)(dictApplicative)(v));
  };
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Maybe_First.First)(traverse(traversableMaybe)(dictApplicative)(f)(v));
    };
  };
});
var traversableLast = new Traversable(function () {
  return Data_Foldable.foldableLast;
}, function () {
  return Data_Maybe_Last.functorLast;
}, function (dictApplicative) {
  return function (v) {
    return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Maybe_Last.Last)(sequence(traversableMaybe)(dictApplicative)(v));
  };
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Maybe_Last.Last)(traverse(traversableMaybe)(dictApplicative)(f)(v));
    };
  };
});

var traverseDefault = function traverseDefault(dictTraversable) {
  return function (dictApplicative) {
    return function (f) {
      return function (ta) {
        return sequence(dictTraversable)(dictApplicative)(Data_Functor.map(dictTraversable.Functor0())(f)(ta));
      };
    };
  };
};

var mapAccumR = function mapAccumR(dictTraversable) {
  return function (f) {
    return function (s0) {
      return function (xs) {
        return Data_Traversable_Accum_Internal.stateR(traverse(dictTraversable)(Data_Traversable_Accum_Internal.applicativeStateR)(function (a) {
          return function (s) {
            return f(s)(a);
          };
        })(xs))(s0);
      };
    };
  };
};

var scanr = function scanr(dictTraversable) {
  return function (f) {
    return function (b0) {
      return function (xs) {
        return mapAccumR(dictTraversable)(function (b) {
          return function (a) {
            var b$prime = f(a)(b);
            return {
              accum: b$prime,
              value: b$prime
            };
          };
        })(b0)(xs).value;
      };
    };
  };
};

var mapAccumL = function mapAccumL(dictTraversable) {
  return function (f) {
    return function (s0) {
      return function (xs) {
        return Data_Traversable_Accum_Internal.stateL(traverse(dictTraversable)(Data_Traversable_Accum_Internal.applicativeStateL)(function (a) {
          return function (s) {
            return f(s)(a);
          };
        })(xs))(s0);
      };
    };
  };
};

var scanl = function scanl(dictTraversable) {
  return function (f) {
    return function (b0) {
      return function (xs) {
        return mapAccumL(dictTraversable)(function (b) {
          return function (a) {
            var b$prime = f(b)(a);
            return {
              accum: b$prime,
              value: b$prime
            };
          };
        })(b0)(xs).value;
      };
    };
  };
};

var $$for = function $$for(dictApplicative) {
  return function (dictTraversable) {
    return function (x) {
      return function (f) {
        return traverse(dictTraversable)(dictApplicative)(f)(x);
      };
    };
  };
};

module.exports = {
  Traversable: Traversable,
  traverse: traverse,
  sequence: sequence,
  traverseDefault: traverseDefault,
  sequenceDefault: sequenceDefault,
  "for": $$for,
  scanl: scanl,
  scanr: scanr,
  mapAccumL: mapAccumL,
  mapAccumR: mapAccumR,
  traversableArray: traversableArray,
  traversableMaybe: traversableMaybe,
  traversableFirst: traversableFirst,
  traversableLast: traversableLast,
  traversableAdditive: traversableAdditive,
  traversableDual: traversableDual,
  traversableConj: traversableConj,
  traversableDisj: traversableDisj,
  traversableMultiplicative: traversableMultiplicative
};
},{"./foreign.js":"../output/Data.Traversable/foreign.js","../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Foldable/index.js":"../output/Data.Foldable/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Maybe.First/index.js":"../output/Data.Maybe.First/index.js","../Data.Maybe.Last/index.js":"../output/Data.Maybe.Last/index.js","../Data.Monoid.Additive/index.js":"../output/Data.Monoid.Additive/index.js","../Data.Monoid.Conj/index.js":"../output/Data.Monoid.Conj/index.js","../Data.Monoid.Disj/index.js":"../output/Data.Monoid.Disj/index.js","../Data.Monoid.Dual/index.js":"../output/Data.Monoid.Dual/index.js","../Data.Monoid.Multiplicative/index.js":"../output/Data.Monoid.Multiplicative/index.js","../Data.Traversable.Accum.Internal/index.js":"../output/Data.Traversable.Accum.Internal/index.js"}],"../output/Data.TraversableWithIndex/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_FoldableWithIndex = require("../Data.FoldableWithIndex/index.js");

var Data_Function = require("../Data.Function/index.js");

var Data_FunctorWithIndex = require("../Data.FunctorWithIndex/index.js");

var Data_Traversable = require("../Data.Traversable/index.js");

var Data_Traversable_Accum_Internal = require("../Data.Traversable.Accum.Internal/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var TraversableWithIndex = function TraversableWithIndex(FoldableWithIndex1, FunctorWithIndex0, Traversable2, traverseWithIndex) {
  this.FoldableWithIndex1 = FoldableWithIndex1;
  this.FunctorWithIndex0 = FunctorWithIndex0;
  this.Traversable2 = Traversable2;
  this.traverseWithIndex = traverseWithIndex;
};

var traverseWithIndexDefault = function traverseWithIndexDefault(dictTraversableWithIndex) {
  return function (dictApplicative) {
    return function (f) {
      var $19 = Data_Traversable.sequence(dictTraversableWithIndex.Traversable2())(dictApplicative);
      var $20 = Data_FunctorWithIndex.mapWithIndex(dictTraversableWithIndex.FunctorWithIndex0())(f);
      return function ($21) {
        return $19($20($21));
      };
    };
  };
};

var traverseWithIndex = function traverseWithIndex(dict) {
  return dict.traverseWithIndex;
};

var traverseDefault = function traverseDefault(dictTraversableWithIndex) {
  return function (dictApplicative) {
    return function (f) {
      return traverseWithIndex(dictTraversableWithIndex)(dictApplicative)(Data_Function["const"](f));
    };
  };
};

var traversableWithIndexMultiplicative = new TraversableWithIndex(function () {
  return Data_FoldableWithIndex.foldableWithIndexMultiplicative;
}, function () {
  return Data_FunctorWithIndex.functorWithIndexMultiplicative;
}, function () {
  return Data_Traversable.traversableMultiplicative;
}, function (dictApplicative) {
  return function (f) {
    return Data_Traversable.traverse(Data_Traversable.traversableMultiplicative)(dictApplicative)(f(Data_Unit.unit));
  };
});
var traversableWithIndexMaybe = new TraversableWithIndex(function () {
  return Data_FoldableWithIndex.foldableWithIndexMaybe;
}, function () {
  return Data_FunctorWithIndex.functorWithIndexMaybe;
}, function () {
  return Data_Traversable.traversableMaybe;
}, function (dictApplicative) {
  return function (f) {
    return Data_Traversable.traverse(Data_Traversable.traversableMaybe)(dictApplicative)(f(Data_Unit.unit));
  };
});
var traversableWithIndexLast = new TraversableWithIndex(function () {
  return Data_FoldableWithIndex.foldableWithIndexLast;
}, function () {
  return Data_FunctorWithIndex.functorWithIndexLast;
}, function () {
  return Data_Traversable.traversableLast;
}, function (dictApplicative) {
  return function (f) {
    return Data_Traversable.traverse(Data_Traversable.traversableLast)(dictApplicative)(f(Data_Unit.unit));
  };
});
var traversableWithIndexFirst = new TraversableWithIndex(function () {
  return Data_FoldableWithIndex.foldableWithIndexFirst;
}, function () {
  return Data_FunctorWithIndex.functorWithIndexFirst;
}, function () {
  return Data_Traversable.traversableFirst;
}, function (dictApplicative) {
  return function (f) {
    return Data_Traversable.traverse(Data_Traversable.traversableFirst)(dictApplicative)(f(Data_Unit.unit));
  };
});
var traversableWithIndexDual = new TraversableWithIndex(function () {
  return Data_FoldableWithIndex.foldableWithIndexDual;
}, function () {
  return Data_FunctorWithIndex.functorWithIndexDual;
}, function () {
  return Data_Traversable.traversableDual;
}, function (dictApplicative) {
  return function (f) {
    return Data_Traversable.traverse(Data_Traversable.traversableDual)(dictApplicative)(f(Data_Unit.unit));
  };
});
var traversableWithIndexDisj = new TraversableWithIndex(function () {
  return Data_FoldableWithIndex.foldableWithIndexDisj;
}, function () {
  return Data_FunctorWithIndex.functorWithIndexDisj;
}, function () {
  return Data_Traversable.traversableDisj;
}, function (dictApplicative) {
  return function (f) {
    return Data_Traversable.traverse(Data_Traversable.traversableDisj)(dictApplicative)(f(Data_Unit.unit));
  };
});
var traversableWithIndexConj = new TraversableWithIndex(function () {
  return Data_FoldableWithIndex.foldableWithIndexConj;
}, function () {
  return Data_FunctorWithIndex.functorWithIndexConj;
}, function () {
  return Data_Traversable.traversableConj;
}, function (dictApplicative) {
  return function (f) {
    return Data_Traversable.traverse(Data_Traversable.traversableConj)(dictApplicative)(f(Data_Unit.unit));
  };
});
var traversableWithIndexArray = new TraversableWithIndex(function () {
  return Data_FoldableWithIndex.foldableWithIndexArray;
}, function () {
  return Data_FunctorWithIndex.functorWithIndexArray;
}, function () {
  return Data_Traversable.traversableArray;
}, function (dictApplicative) {
  return traverseWithIndexDefault(traversableWithIndexArray)(dictApplicative);
});
var traversableWithIndexAdditive = new TraversableWithIndex(function () {
  return Data_FoldableWithIndex.foldableWithIndexAdditive;
}, function () {
  return Data_FunctorWithIndex.functorWithIndexAdditive;
}, function () {
  return Data_Traversable.traversableAdditive;
}, function (dictApplicative) {
  return function (f) {
    return Data_Traversable.traverse(Data_Traversable.traversableAdditive)(dictApplicative)(f(Data_Unit.unit));
  };
});

var mapAccumRWithIndex = function mapAccumRWithIndex(dictTraversableWithIndex) {
  return function (f) {
    return function (s0) {
      return function (xs) {
        return Data_Traversable_Accum_Internal.stateR(traverseWithIndex(dictTraversableWithIndex)(Data_Traversable_Accum_Internal.applicativeStateR)(function (i) {
          return function (a) {
            return function (s) {
              return f(i)(s)(a);
            };
          };
        })(xs))(s0);
      };
    };
  };
};

var scanrWithIndex = function scanrWithIndex(dictTraversableWithIndex) {
  return function (f) {
    return function (b0) {
      return function (xs) {
        return mapAccumRWithIndex(dictTraversableWithIndex)(function (i) {
          return function (b) {
            return function (a) {
              var b$prime = f(i)(a)(b);
              return {
                accum: b$prime,
                value: b$prime
              };
            };
          };
        })(b0)(xs).value;
      };
    };
  };
};

var mapAccumLWithIndex = function mapAccumLWithIndex(dictTraversableWithIndex) {
  return function (f) {
    return function (s0) {
      return function (xs) {
        return Data_Traversable_Accum_Internal.stateL(traverseWithIndex(dictTraversableWithIndex)(Data_Traversable_Accum_Internal.applicativeStateL)(function (i) {
          return function (a) {
            return function (s) {
              return f(i)(s)(a);
            };
          };
        })(xs))(s0);
      };
    };
  };
};

var scanlWithIndex = function scanlWithIndex(dictTraversableWithIndex) {
  return function (f) {
    return function (b0) {
      return function (xs) {
        return mapAccumLWithIndex(dictTraversableWithIndex)(function (i) {
          return function (b) {
            return function (a) {
              var b$prime = f(i)(b)(a);
              return {
                accum: b$prime,
                value: b$prime
              };
            };
          };
        })(b0)(xs).value;
      };
    };
  };
};

var forWithIndex = function forWithIndex(dictApplicative) {
  return function (dictTraversableWithIndex) {
    return Data_Function.flip(traverseWithIndex(dictTraversableWithIndex)(dictApplicative));
  };
};

module.exports = {
  TraversableWithIndex: TraversableWithIndex,
  traverseWithIndex: traverseWithIndex,
  traverseWithIndexDefault: traverseWithIndexDefault,
  forWithIndex: forWithIndex,
  scanlWithIndex: scanlWithIndex,
  mapAccumLWithIndex: mapAccumLWithIndex,
  scanrWithIndex: scanrWithIndex,
  mapAccumRWithIndex: mapAccumRWithIndex,
  traverseDefault: traverseDefault,
  traversableWithIndexArray: traversableWithIndexArray,
  traversableWithIndexMaybe: traversableWithIndexMaybe,
  traversableWithIndexFirst: traversableWithIndexFirst,
  traversableWithIndexLast: traversableWithIndexLast,
  traversableWithIndexAdditive: traversableWithIndexAdditive,
  traversableWithIndexDual: traversableWithIndexDual,
  traversableWithIndexConj: traversableWithIndexConj,
  traversableWithIndexDisj: traversableWithIndexDisj,
  traversableWithIndexMultiplicative: traversableWithIndexMultiplicative
};
},{"../Data.FoldableWithIndex/index.js":"../output/Data.FoldableWithIndex/index.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.FunctorWithIndex/index.js":"../output/Data.FunctorWithIndex/index.js","../Data.Traversable/index.js":"../output/Data.Traversable/index.js","../Data.Traversable.Accum.Internal/index.js":"../output/Data.Traversable.Accum.Internal/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Control.Biapplicative/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Biapplicative = function Biapplicative(Biapply0, bipure) {
  this.Biapply0 = Biapply0;
  this.bipure = bipure;
};

var bipure = function bipure(dict) {
  return dict.bipure;
};

module.exports = {
  bipure: bipure,
  Biapplicative: Biapplicative
};
},{}],"../output/Data.Bifunctor/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Category = require("../Control.Category/index.js");

var Bifunctor = function Bifunctor(bimap) {
  this.bimap = bimap;
};

var bimap = function bimap(dict) {
  return dict.bimap;
};

var lmap = function lmap(dictBifunctor) {
  return function (f) {
    return bimap(dictBifunctor)(f)(Control_Category.identity(Control_Category.categoryFn));
  };
};

var rmap = function rmap(dictBifunctor) {
  return bimap(dictBifunctor)(Control_Category.identity(Control_Category.categoryFn));
};

module.exports = {
  bimap: bimap,
  Bifunctor: Bifunctor,
  lmap: lmap,
  rmap: rmap
};
},{"../Control.Category/index.js":"../output/Control.Category/index.js"}],"../output/Control.Biapply/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Category = require("../Control.Category/index.js");

var Data_Bifunctor = require("../Data.Bifunctor/index.js");

var Data_Function = require("../Data.Function/index.js");

var Biapply = function Biapply(Bifunctor0, biapply) {
  this.Bifunctor0 = Bifunctor0;
  this.biapply = biapply;
};

var biapply = function biapply(dict) {
  return dict.biapply;
};

var biapplyFirst = function biapplyFirst(dictBiapply) {
  return function (a) {
    return function (b) {
      return biapply(dictBiapply)(Control_Category.identity(Control_Category.categoryFn)(Data_Bifunctor.bimap(dictBiapply.Bifunctor0())(Data_Function["const"](Control_Category.identity(Control_Category.categoryFn)))(Data_Function["const"](Control_Category.identity(Control_Category.categoryFn))))(a))(b);
    };
  };
};

var biapplySecond = function biapplySecond(dictBiapply) {
  return function (a) {
    return function (b) {
      return biapply(dictBiapply)(Control_Category.identity(Control_Category.categoryFn)(Data_Bifunctor.bimap(dictBiapply.Bifunctor0())(Data_Function["const"])(Data_Function["const"]))(a))(b);
    };
  };
};

var bilift2 = function bilift2(dictBiapply) {
  return function (f) {
    return function (g) {
      return function (a) {
        return function (b) {
          return biapply(dictBiapply)(Control_Category.identity(Control_Category.categoryFn)(Data_Bifunctor.bimap(dictBiapply.Bifunctor0())(f)(g))(a))(b);
        };
      };
    };
  };
};

var bilift3 = function bilift3(dictBiapply) {
  return function (f) {
    return function (g) {
      return function (a) {
        return function (b) {
          return function (c) {
            return biapply(dictBiapply)(biapply(dictBiapply)(Control_Category.identity(Control_Category.categoryFn)(Data_Bifunctor.bimap(dictBiapply.Bifunctor0())(f)(g))(a))(b))(c);
          };
        };
      };
    };
  };
};

module.exports = {
  biapply: biapply,
  Biapply: Biapply,
  biapplyFirst: biapplyFirst,
  biapplySecond: biapplySecond,
  bilift2: bilift2,
  bilift3: bilift3
};
},{"../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Bifunctor/index.js":"../output/Data.Bifunctor/index.js","../Data.Function/index.js":"../output/Data.Function/index.js"}],"../output/Control.Lazy/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_Unit = require("../Data.Unit/index.js");

var Lazy = function Lazy(defer) {
  this.defer = defer;
};

var lazyUnit = new Lazy(function (v) {
  return Data_Unit.unit;
});
var lazyFn = new Lazy(function (f) {
  return function (x) {
    return f(Data_Unit.unit)(x);
  };
});

var defer = function defer(dict) {
  return dict.defer;
};

var fix = function fix(dictLazy) {
  return function (f) {
    var go = defer(dictLazy)(function (v) {
      return f(go);
    });
    return go;
  };
};

module.exports = {
  defer: defer,
  Lazy: Lazy,
  fix: fix,
  lazyFn: lazyFn,
  lazyUnit: lazyUnit
};
},{"../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.Bifoldable/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Category = require("../Control.Category/index.js");

var Data_Foldable = require("../Data.Foldable/index.js");

var Data_Function = require("../Data.Function/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Monoid_Conj = require("../Data.Monoid.Conj/index.js");

var Data_Monoid_Disj = require("../Data.Monoid.Disj/index.js");

var Data_Monoid_Dual = require("../Data.Monoid.Dual/index.js");

var Data_Monoid_Endo = require("../Data.Monoid.Endo/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Bifoldable = function Bifoldable(bifoldMap, bifoldl, bifoldr) {
  this.bifoldMap = bifoldMap;
  this.bifoldl = bifoldl;
  this.bifoldr = bifoldr;
};

var bifoldr = function bifoldr(dict) {
  return dict.bifoldr;
};

var bitraverse_ = function bitraverse_(dictBifoldable) {
  return function (dictApplicative) {
    return function (f) {
      return function (g) {
        return bifoldr(dictBifoldable)(function () {
          var $97 = Control_Apply.applySecond(dictApplicative.Apply0());
          return function ($98) {
            return $97(f($98));
          };
        }())(function () {
          var $99 = Control_Apply.applySecond(dictApplicative.Apply0());
          return function ($100) {
            return $99(g($100));
          };
        }())(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
      };
    };
  };
};

var bifor_ = function bifor_(dictBifoldable) {
  return function (dictApplicative) {
    return function (t) {
      return function (f) {
        return function (g) {
          return bitraverse_(dictBifoldable)(dictApplicative)(f)(g)(t);
        };
      };
    };
  };
};

var bisequence_ = function bisequence_(dictBifoldable) {
  return function (dictApplicative) {
    return bitraverse_(dictBifoldable)(dictApplicative)(Control_Category.identity(Control_Category.categoryFn))(Control_Category.identity(Control_Category.categoryFn));
  };
};

var bifoldl = function bifoldl(dict) {
  return dict.bifoldl;
};

var bifoldableJoker = function bifoldableJoker(dictFoldable) {
  return new Bifoldable(function (dictMonoid) {
    return function (v) {
      return function (r) {
        return function (v1) {
          return Data_Foldable.foldMap(dictFoldable)(dictMonoid)(r)(v1);
        };
      };
    };
  }, function (v) {
    return function (r) {
      return function (u) {
        return function (v1) {
          return Data_Foldable.foldl(dictFoldable)(r)(u)(v1);
        };
      };
    };
  }, function (v) {
    return function (r) {
      return function (u) {
        return function (v1) {
          return Data_Foldable.foldr(dictFoldable)(r)(u)(v1);
        };
      };
    };
  });
};

var bifoldableClown = function bifoldableClown(dictFoldable) {
  return new Bifoldable(function (dictMonoid) {
    return function (l) {
      return function (v) {
        return function (v1) {
          return Data_Foldable.foldMap(dictFoldable)(dictMonoid)(l)(v1);
        };
      };
    };
  }, function (l) {
    return function (v) {
      return function (u) {
        return function (v1) {
          return Data_Foldable.foldl(dictFoldable)(l)(u)(v1);
        };
      };
    };
  }, function (l) {
    return function (v) {
      return function (u) {
        return function (v1) {
          return Data_Foldable.foldr(dictFoldable)(l)(u)(v1);
        };
      };
    };
  });
};

var bifoldMapDefaultR = function bifoldMapDefaultR(dictBifoldable) {
  return function (dictMonoid) {
    return function (f) {
      return function (g) {
        return bifoldr(dictBifoldable)(function () {
          var $101 = Data_Semigroup.append(dictMonoid.Semigroup0());
          return function ($102) {
            return $101(f($102));
          };
        }())(function () {
          var $103 = Data_Semigroup.append(dictMonoid.Semigroup0());
          return function ($104) {
            return $103(g($104));
          };
        }())(Data_Monoid.mempty(dictMonoid));
      };
    };
  };
};

var bifoldMapDefaultL = function bifoldMapDefaultL(dictBifoldable) {
  return function (dictMonoid) {
    return function (f) {
      return function (g) {
        return bifoldl(dictBifoldable)(function (m) {
          return function (a) {
            return Data_Semigroup.append(dictMonoid.Semigroup0())(m)(f(a));
          };
        })(function (m) {
          return function (b) {
            return Data_Semigroup.append(dictMonoid.Semigroup0())(m)(g(b));
          };
        })(Data_Monoid.mempty(dictMonoid));
      };
    };
  };
};

var bifoldMap = function bifoldMap(dict) {
  return dict.bifoldMap;
};

var bifoldableFlip = function bifoldableFlip(dictBifoldable) {
  return new Bifoldable(function (dictMonoid) {
    return function (r) {
      return function (l) {
        return function (v) {
          return bifoldMap(dictBifoldable)(dictMonoid)(l)(r)(v);
        };
      };
    };
  }, function (r) {
    return function (l) {
      return function (u) {
        return function (v) {
          return bifoldl(dictBifoldable)(l)(r)(u)(v);
        };
      };
    };
  }, function (r) {
    return function (l) {
      return function (u) {
        return function (v) {
          return bifoldr(dictBifoldable)(l)(r)(u)(v);
        };
      };
    };
  });
};

var bifoldableWrap = function bifoldableWrap(dictBifoldable) {
  return new Bifoldable(function (dictMonoid) {
    return function (l) {
      return function (r) {
        return function (v) {
          return bifoldMap(dictBifoldable)(dictMonoid)(l)(r)(v);
        };
      };
    };
  }, function (l) {
    return function (r) {
      return function (u) {
        return function (v) {
          return bifoldl(dictBifoldable)(l)(r)(u)(v);
        };
      };
    };
  }, function (l) {
    return function (r) {
      return function (u) {
        return function (v) {
          return bifoldr(dictBifoldable)(l)(r)(u)(v);
        };
      };
    };
  });
};

var bifoldlDefault = function bifoldlDefault(dictBifoldable) {
  return function (f) {
    return function (g) {
      return function (z) {
        return function (p) {
          return Data_Newtype.unwrap(Data_Newtype.newtypeEndo)(Data_Newtype.unwrap(Data_Newtype.newtypeDual)(bifoldMap(dictBifoldable)(Data_Monoid_Dual.monoidDual(Data_Monoid_Endo.monoidEndo(Control_Category.categoryFn)))(function () {
            var $105 = Data_Function.flip(f);
            return function ($106) {
              return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo($105($106)));
            };
          }())(function () {
            var $107 = Data_Function.flip(g);
            return function ($108) {
              return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo($107($108)));
            };
          }())(p)))(z);
        };
      };
    };
  };
};

var bifoldrDefault = function bifoldrDefault(dictBifoldable) {
  return function (f) {
    return function (g) {
      return function (z) {
        return function (p) {
          return Data_Newtype.unwrap(Data_Newtype.newtypeEndo)(bifoldMap(dictBifoldable)(Data_Monoid_Endo.monoidEndo(Control_Category.categoryFn))(function ($109) {
            return Data_Monoid_Endo.Endo(f($109));
          })(function ($110) {
            return Data_Monoid_Endo.Endo(g($110));
          })(p))(z);
        };
      };
    };
  };
};

var bifoldableProduct = function bifoldableProduct(dictBifoldable) {
  return function (dictBifoldable1) {
    return new Bifoldable(function (dictMonoid) {
      return function (l) {
        return function (r) {
          return function (v) {
            return Data_Semigroup.append(dictMonoid.Semigroup0())(bifoldMap(dictBifoldable)(dictMonoid)(l)(r)(v.value0))(bifoldMap(dictBifoldable1)(dictMonoid)(l)(r)(v.value1));
          };
        };
      };
    }, function (l) {
      return function (r) {
        return function (u) {
          return function (m) {
            return bifoldlDefault(bifoldableProduct(dictBifoldable)(dictBifoldable1))(l)(r)(u)(m);
          };
        };
      };
    }, function (l) {
      return function (r) {
        return function (u) {
          return function (m) {
            return bifoldrDefault(bifoldableProduct(dictBifoldable)(dictBifoldable1))(l)(r)(u)(m);
          };
        };
      };
    });
  };
};

var bifold = function bifold(dictBifoldable) {
  return function (dictMonoid) {
    return bifoldMap(dictBifoldable)(dictMonoid)(Control_Category.identity(Control_Category.categoryFn))(Control_Category.identity(Control_Category.categoryFn));
  };
};

var biany = function biany(dictBifoldable) {
  return function (dictBooleanAlgebra) {
    return function (p) {
      return function (q) {
        var $111 = Data_Newtype.unwrap(Data_Newtype.newtypeDisj);
        var $112 = bifoldMap(dictBifoldable)(Data_Monoid_Disj.monoidDisj(dictBooleanAlgebra.HeytingAlgebra0()))(function ($114) {
          return Data_Monoid_Disj.Disj(p($114));
        })(function ($115) {
          return Data_Monoid_Disj.Disj(q($115));
        });
        return function ($113) {
          return $111($112($113));
        };
      };
    };
  };
};

var biall = function biall(dictBifoldable) {
  return function (dictBooleanAlgebra) {
    return function (p) {
      return function (q) {
        var $116 = Data_Newtype.unwrap(Data_Newtype.newtypeConj);
        var $117 = bifoldMap(dictBifoldable)(Data_Monoid_Conj.monoidConj(dictBooleanAlgebra.HeytingAlgebra0()))(function ($119) {
          return Data_Monoid_Conj.Conj(p($119));
        })(function ($120) {
          return Data_Monoid_Conj.Conj(q($120));
        });
        return function ($118) {
          return $116($117($118));
        };
      };
    };
  };
};

module.exports = {
  bifoldMap: bifoldMap,
  bifoldl: bifoldl,
  bifoldr: bifoldr,
  Bifoldable: Bifoldable,
  bifoldrDefault: bifoldrDefault,
  bifoldlDefault: bifoldlDefault,
  bifoldMapDefaultR: bifoldMapDefaultR,
  bifoldMapDefaultL: bifoldMapDefaultL,
  bifold: bifold,
  bitraverse_: bitraverse_,
  bifor_: bifor_,
  bisequence_: bisequence_,
  biany: biany,
  biall: biall,
  bifoldableClown: bifoldableClown,
  bifoldableJoker: bifoldableJoker,
  bifoldableFlip: bifoldableFlip,
  bifoldableProduct: bifoldableProduct,
  bifoldableWrap: bifoldableWrap
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Foldable/index.js":"../output/Data.Foldable/index.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Monoid.Conj/index.js":"../output/Data.Monoid.Conj/index.js","../Data.Monoid.Disj/index.js":"../output/Data.Monoid.Disj/index.js","../Data.Monoid.Dual/index.js":"../output/Data.Monoid.Dual/index.js","../Data.Monoid.Endo/index.js":"../output/Data.Monoid.Endo/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.Bifunctor.Clown/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Biapplicative = require("../Control.Biapplicative/index.js");

var Control_Biapply = require("../Control.Biapply/index.js");

var Data_Bifunctor = require("../Data.Bifunctor/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Show = require("../Data.Show/index.js");

var Clown = function Clown(x) {
  return x;
};

var showClown = function showClown(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Clown " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var ordClown = function ordClown(dictOrd) {
  return dictOrd;
};

var newtypeClown = new Data_Newtype.Newtype(function (n) {
  return n;
}, Clown);
var functorClown = new Data_Functor.Functor(function (v) {
  return function (v1) {
    return v1;
  };
});

var eqClown = function eqClown(dictEq) {
  return dictEq;
};

var bifunctorClown = function bifunctorClown(dictFunctor) {
  return new Data_Bifunctor.Bifunctor(function (f) {
    return function (v) {
      return function (v1) {
        return Data_Functor.map(dictFunctor)(f)(v1);
      };
    };
  });
};

var biapplyClown = function biapplyClown(dictApply) {
  return new Control_Biapply.Biapply(function () {
    return bifunctorClown(dictApply.Functor0());
  }, function (v) {
    return function (v1) {
      return Control_Apply.apply(dictApply)(v)(v1);
    };
  });
};

var biapplicativeClown = function biapplicativeClown(dictApplicative) {
  return new Control_Biapplicative.Biapplicative(function () {
    return biapplyClown(dictApplicative.Apply0());
  }, function (a) {
    return function (v) {
      return Control_Applicative.pure(dictApplicative)(a);
    };
  });
};

module.exports = {
  Clown: Clown,
  newtypeClown: newtypeClown,
  eqClown: eqClown,
  ordClown: ordClown,
  showClown: showClown,
  functorClown: functorClown,
  bifunctorClown: bifunctorClown,
  biapplyClown: biapplyClown,
  biapplicativeClown: biapplicativeClown
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Biapplicative/index.js":"../output/Control.Biapplicative/index.js","../Control.Biapply/index.js":"../output/Control.Biapply/index.js","../Data.Bifunctor/index.js":"../output/Data.Bifunctor/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Bifunctor.Flip/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Biapplicative = require("../Control.Biapplicative/index.js");

var Control_Biapply = require("../Control.Biapply/index.js");

var Data_Bifunctor = require("../Data.Bifunctor/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Show = require("../Data.Show/index.js");

var Flip = function Flip(x) {
  return x;
};

var showFlip = function showFlip(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Flip " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var ordFlip = function ordFlip(dictOrd) {
  return dictOrd;
};

var newtypeFlip = new Data_Newtype.Newtype(function (n) {
  return n;
}, Flip);

var functorFlip = function functorFlip(dictBifunctor) {
  return new Data_Functor.Functor(function (f) {
    return function (v) {
      return Data_Bifunctor.lmap(dictBifunctor)(f)(v);
    };
  });
};

var eqFlip = function eqFlip(dictEq) {
  return dictEq;
};

var bifunctorFlip = function bifunctorFlip(dictBifunctor) {
  return new Data_Bifunctor.Bifunctor(function (f) {
    return function (g) {
      return function (v) {
        return Data_Bifunctor.bimap(dictBifunctor)(g)(f)(v);
      };
    };
  });
};

var biapplyFlip = function biapplyFlip(dictBiapply) {
  return new Control_Biapply.Biapply(function () {
    return bifunctorFlip(dictBiapply.Bifunctor0());
  }, function (v) {
    return function (v1) {
      return Control_Biapply.biapply(dictBiapply)(v)(v1);
    };
  });
};

var biapplicativeFlip = function biapplicativeFlip(dictBiapplicative) {
  return new Control_Biapplicative.Biapplicative(function () {
    return biapplyFlip(dictBiapplicative.Biapply0());
  }, function (a) {
    return function (b) {
      return Control_Biapplicative.bipure(dictBiapplicative)(b)(a);
    };
  });
};

module.exports = {
  Flip: Flip,
  newtypeFlip: newtypeFlip,
  eqFlip: eqFlip,
  ordFlip: ordFlip,
  showFlip: showFlip,
  functorFlip: functorFlip,
  bifunctorFlip: bifunctorFlip,
  biapplyFlip: biapplyFlip,
  biapplicativeFlip: biapplicativeFlip
};
},{"../Control.Biapplicative/index.js":"../output/Control.Biapplicative/index.js","../Control.Biapply/index.js":"../output/Control.Biapply/index.js","../Data.Bifunctor/index.js":"../output/Data.Bifunctor/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Bifunctor.Joker/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Biapplicative = require("../Control.Biapplicative/index.js");

var Control_Biapply = require("../Control.Biapply/index.js");

var Data_Bifunctor = require("../Data.Bifunctor/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Show = require("../Data.Show/index.js");

var Joker = function Joker(x) {
  return x;
};

var showJoker = function showJoker(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Joker " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var ordJoker = function ordJoker(dictOrd) {
  return dictOrd;
};

var newtypeJoker = new Data_Newtype.Newtype(function (n) {
  return n;
}, Joker);

var functorJoker = function functorJoker(dictFunctor) {
  return new Data_Functor.Functor(function (g) {
    return function (v) {
      return Data_Functor.map(dictFunctor)(g)(v);
    };
  });
};

var eqJoker = function eqJoker(dictEq) {
  return dictEq;
};

var bifunctorJoker = function bifunctorJoker(dictFunctor) {
  return new Data_Bifunctor.Bifunctor(function (v) {
    return function (g) {
      return function (v1) {
        return Data_Functor.map(dictFunctor)(g)(v1);
      };
    };
  });
};

var biapplyJoker = function biapplyJoker(dictApply) {
  return new Control_Biapply.Biapply(function () {
    return bifunctorJoker(dictApply.Functor0());
  }, function (v) {
    return function (v1) {
      return Control_Apply.apply(dictApply)(v)(v1);
    };
  });
};

var biapplicativeJoker = function biapplicativeJoker(dictApplicative) {
  return new Control_Biapplicative.Biapplicative(function () {
    return biapplyJoker(dictApplicative.Apply0());
  }, function (v) {
    return function (b) {
      return Control_Applicative.pure(dictApplicative)(b);
    };
  });
};

module.exports = {
  Joker: Joker,
  newtypeJoker: newtypeJoker,
  eqJoker: eqJoker,
  ordJoker: ordJoker,
  showJoker: showJoker,
  functorJoker: functorJoker,
  bifunctorJoker: bifunctorJoker,
  biapplyJoker: biapplyJoker,
  biapplicativeJoker: biapplicativeJoker
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Biapplicative/index.js":"../output/Control.Biapplicative/index.js","../Control.Biapply/index.js":"../output/Control.Biapply/index.js","../Data.Bifunctor/index.js":"../output/Data.Bifunctor/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Bifunctor.Product/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Biapplicative = require("../Control.Biapplicative/index.js");

var Control_Biapply = require("../Control.Biapply/index.js");

var Data_Bifunctor = require("../Data.Bifunctor/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Ordering = require("../Data.Ordering/index.js");

var Data_Show = require("../Data.Show/index.js");

var Product = function () {
  function Product(value0, value1) {
    this.value0 = value0;
    this.value1 = value1;
  }

  ;

  Product.create = function (value0) {
    return function (value1) {
      return new Product(value0, value1);
    };
  };

  return Product;
}();

var showProduct = function showProduct(dictShow) {
  return function (dictShow1) {
    return new Data_Show.Show(function (v) {
      return "(Product " + (Data_Show.show(dictShow)(v.value0) + (" " + (Data_Show.show(dictShow1)(v.value1) + ")")));
    });
  };
};

var eqProduct = function eqProduct(dictEq) {
  return function (dictEq1) {
    return new Data_Eq.Eq(function (x) {
      return function (y) {
        return Data_Eq.eq(dictEq)(x.value0)(y.value0) && Data_Eq.eq(dictEq1)(x.value1)(y.value1);
      };
    });
  };
};

var ordProduct = function ordProduct(dictOrd) {
  return function (dictOrd1) {
    return new Data_Ord.Ord(function () {
      return eqProduct(dictOrd.Eq0())(dictOrd1.Eq0());
    }, function (x) {
      return function (y) {
        var v = Data_Ord.compare(dictOrd)(x.value0)(y.value0);

        if (v instanceof Data_Ordering.LT) {
          return Data_Ordering.LT.value;
        }

        ;

        if (v instanceof Data_Ordering.GT) {
          return Data_Ordering.GT.value;
        }

        ;
        return Data_Ord.compare(dictOrd1)(x.value1)(y.value1);
      };
    });
  };
};

var bifunctorProduct = function bifunctorProduct(dictBifunctor) {
  return function (dictBifunctor1) {
    return new Data_Bifunctor.Bifunctor(function (f) {
      return function (g) {
        return function (v) {
          return new Product(Data_Bifunctor.bimap(dictBifunctor)(f)(g)(v.value0), Data_Bifunctor.bimap(dictBifunctor1)(f)(g)(v.value1));
        };
      };
    });
  };
};

var biapplyProduct = function biapplyProduct(dictBiapply) {
  return function (dictBiapply1) {
    return new Control_Biapply.Biapply(function () {
      return bifunctorProduct(dictBiapply.Bifunctor0())(dictBiapply1.Bifunctor0());
    }, function (v) {
      return function (v1) {
        return new Product(Control_Biapply.biapply(dictBiapply)(v.value0)(v1.value0), Control_Biapply.biapply(dictBiapply1)(v.value1)(v1.value1));
      };
    });
  };
};

var biapplicativeProduct = function biapplicativeProduct(dictBiapplicative) {
  return function (dictBiapplicative1) {
    return new Control_Biapplicative.Biapplicative(function () {
      return biapplyProduct(dictBiapplicative.Biapply0())(dictBiapplicative1.Biapply0());
    }, function (a) {
      return function (b) {
        return new Product(Control_Biapplicative.bipure(dictBiapplicative)(a)(b), Control_Biapplicative.bipure(dictBiapplicative1)(a)(b));
      };
    });
  };
};

module.exports = {
  Product: Product,
  eqProduct: eqProduct,
  ordProduct: ordProduct,
  showProduct: showProduct,
  bifunctorProduct: bifunctorProduct,
  biapplyProduct: biapplyProduct,
  biapplicativeProduct: biapplicativeProduct
};
},{"../Control.Biapplicative/index.js":"../output/Control.Biapplicative/index.js","../Control.Biapply/index.js":"../output/Control.Biapply/index.js","../Data.Bifunctor/index.js":"../output/Data.Bifunctor/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Ordering/index.js":"../output/Data.Ordering/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Bifunctor.Wrap/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Biapplicative = require("../Control.Biapplicative/index.js");

var Control_Biapply = require("../Control.Biapply/index.js");

var Data_Bifunctor = require("../Data.Bifunctor/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Show = require("../Data.Show/index.js");

var Wrap = function Wrap(x) {
  return x;
};

var showWrap = function showWrap(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Wrap " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var ordWrap = function ordWrap(dictOrd) {
  return dictOrd;
};

var newtypeWrap = new Data_Newtype.Newtype(function (n) {
  return n;
}, Wrap);

var functorWrap = function functorWrap(dictBifunctor) {
  return new Data_Functor.Functor(function (f) {
    return function (v) {
      return Data_Bifunctor.rmap(dictBifunctor)(f)(v);
    };
  });
};

var eqWrap = function eqWrap(dictEq) {
  return dictEq;
};

var bifunctorWrap = function bifunctorWrap(dictBifunctor) {
  return new Data_Bifunctor.Bifunctor(function (f) {
    return function (g) {
      return function (v) {
        return Data_Bifunctor.bimap(dictBifunctor)(f)(g)(v);
      };
    };
  });
};

var biapplyWrap = function biapplyWrap(dictBiapply) {
  return new Control_Biapply.Biapply(function () {
    return bifunctorWrap(dictBiapply.Bifunctor0());
  }, function (v) {
    return function (v1) {
      return Control_Biapply.biapply(dictBiapply)(v)(v1);
    };
  });
};

var biapplicativeWrap = function biapplicativeWrap(dictBiapplicative) {
  return new Control_Biapplicative.Biapplicative(function () {
    return biapplyWrap(dictBiapplicative.Biapply0());
  }, function (a) {
    return function (b) {
      return Control_Biapplicative.bipure(dictBiapplicative)(a)(b);
    };
  });
};

module.exports = {
  Wrap: Wrap,
  newtypeWrap: newtypeWrap,
  eqWrap: eqWrap,
  ordWrap: ordWrap,
  showWrap: showWrap,
  functorWrap: functorWrap,
  bifunctorWrap: bifunctorWrap,
  biapplyWrap: biapplyWrap,
  biapplicativeWrap: biapplicativeWrap
};
},{"../Control.Biapplicative/index.js":"../output/Control.Biapplicative/index.js","../Control.Biapply/index.js":"../output/Control.Biapply/index.js","../Data.Bifunctor/index.js":"../output/Data.Bifunctor/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Data.Bitraversable/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Category = require("../Control.Category/index.js");

var Data_Bifoldable = require("../Data.Bifoldable/index.js");

var Data_Bifunctor = require("../Data.Bifunctor/index.js");

var Data_Bifunctor_Clown = require("../Data.Bifunctor.Clown/index.js");

var Data_Bifunctor_Flip = require("../Data.Bifunctor.Flip/index.js");

var Data_Bifunctor_Joker = require("../Data.Bifunctor.Joker/index.js");

var Data_Bifunctor_Product = require("../Data.Bifunctor.Product/index.js");

var Data_Bifunctor_Wrap = require("../Data.Bifunctor.Wrap/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Traversable = require("../Data.Traversable/index.js");

var Bitraversable = function Bitraversable(Bifoldable1, Bifunctor0, bisequence, bitraverse) {
  this.Bifoldable1 = Bifoldable1;
  this.Bifunctor0 = Bifunctor0;
  this.bisequence = bisequence;
  this.bitraverse = bitraverse;
};

var bitraverse = function bitraverse(dict) {
  return dict.bitraverse;
};

var lfor = function lfor(dictBitraversable) {
  return function (dictApplicative) {
    return function (t) {
      return function (f) {
        return bitraverse(dictBitraversable)(dictApplicative)(f)(Control_Applicative.pure(dictApplicative))(t);
      };
    };
  };
};

var ltraverse = function ltraverse(dictBitraversable) {
  return function (dictApplicative) {
    return function (f) {
      return bitraverse(dictBitraversable)(dictApplicative)(f)(Control_Applicative.pure(dictApplicative));
    };
  };
};

var rfor = function rfor(dictBitraversable) {
  return function (dictApplicative) {
    return function (t) {
      return function (f) {
        return bitraverse(dictBitraversable)(dictApplicative)(Control_Applicative.pure(dictApplicative))(f)(t);
      };
    };
  };
};

var rtraverse = function rtraverse(dictBitraversable) {
  return function (dictApplicative) {
    return bitraverse(dictBitraversable)(dictApplicative)(Control_Applicative.pure(dictApplicative));
  };
};

var bitraversableJoker = function bitraversableJoker(dictTraversable) {
  return new Bitraversable(function () {
    return Data_Bifoldable.bifoldableJoker(dictTraversable.Foldable1());
  }, function () {
    return Data_Bifunctor_Joker.bifunctorJoker(dictTraversable.Functor0());
  }, function (dictApplicative) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Bifunctor_Joker.Joker)(Data_Traversable.sequence(dictTraversable)(dictApplicative)(v));
    };
  }, function (dictApplicative) {
    return function (v) {
      return function (r) {
        return function (v1) {
          return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Bifunctor_Joker.Joker)(Data_Traversable.traverse(dictTraversable)(dictApplicative)(r)(v1));
        };
      };
    };
  });
};

var bitraversableClown = function bitraversableClown(dictTraversable) {
  return new Bitraversable(function () {
    return Data_Bifoldable.bifoldableClown(dictTraversable.Foldable1());
  }, function () {
    return Data_Bifunctor_Clown.bifunctorClown(dictTraversable.Functor0());
  }, function (dictApplicative) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Bifunctor_Clown.Clown)(Data_Traversable.sequence(dictTraversable)(dictApplicative)(v));
    };
  }, function (dictApplicative) {
    return function (l) {
      return function (v) {
        return function (v1) {
          return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Bifunctor_Clown.Clown)(Data_Traversable.traverse(dictTraversable)(dictApplicative)(l)(v1));
        };
      };
    };
  });
};

var bisequenceDefault = function bisequenceDefault(dictBitraversable) {
  return function (dictApplicative) {
    return bitraverse(dictBitraversable)(dictApplicative)(Control_Category.identity(Control_Category.categoryFn))(Control_Category.identity(Control_Category.categoryFn));
  };
};

var bisequence = function bisequence(dict) {
  return dict.bisequence;
};

var bitraversableFlip = function bitraversableFlip(dictBitraversable) {
  return new Bitraversable(function () {
    return Data_Bifoldable.bifoldableFlip(dictBitraversable.Bifoldable1());
  }, function () {
    return Data_Bifunctor_Flip.bifunctorFlip(dictBitraversable.Bifunctor0());
  }, function (dictApplicative) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Bifunctor_Flip.Flip)(bisequence(dictBitraversable)(dictApplicative)(v));
    };
  }, function (dictApplicative) {
    return function (r) {
      return function (l) {
        return function (v) {
          return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Bifunctor_Flip.Flip)(bitraverse(dictBitraversable)(dictApplicative)(l)(r)(v));
        };
      };
    };
  });
};

var bitraversableProduct = function bitraversableProduct(dictBitraversable) {
  return function (dictBitraversable1) {
    return new Bitraversable(function () {
      return Data_Bifoldable.bifoldableProduct(dictBitraversable.Bifoldable1())(dictBitraversable1.Bifoldable1());
    }, function () {
      return Data_Bifunctor_Product.bifunctorProduct(dictBitraversable.Bifunctor0())(dictBitraversable1.Bifunctor0());
    }, function (dictApplicative) {
      return function (v) {
        return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Bifunctor_Product.Product.create)(bisequence(dictBitraversable)(dictApplicative)(v.value0)))(bisequence(dictBitraversable1)(dictApplicative)(v.value1));
      };
    }, function (dictApplicative) {
      return function (l) {
        return function (r) {
          return function (v) {
            return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Bifunctor_Product.Product.create)(bitraverse(dictBitraversable)(dictApplicative)(l)(r)(v.value0)))(bitraverse(dictBitraversable1)(dictApplicative)(l)(r)(v.value1));
          };
        };
      };
    });
  };
};

var bitraversableWrap = function bitraversableWrap(dictBitraversable) {
  return new Bitraversable(function () {
    return Data_Bifoldable.bifoldableWrap(dictBitraversable.Bifoldable1());
  }, function () {
    return Data_Bifunctor_Wrap.bifunctorWrap(dictBitraversable.Bifunctor0());
  }, function (dictApplicative) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Bifunctor_Wrap.Wrap)(bisequence(dictBitraversable)(dictApplicative)(v));
    };
  }, function (dictApplicative) {
    return function (l) {
      return function (r) {
        return function (v) {
          return Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Bifunctor_Wrap.Wrap)(bitraverse(dictBitraversable)(dictApplicative)(l)(r)(v));
        };
      };
    };
  });
};

var bitraverseDefault = function bitraverseDefault(dictBitraversable) {
  return function (dictApplicative) {
    return function (f) {
      return function (g) {
        return function (t) {
          return bisequence(dictBitraversable)(dictApplicative)(Data_Bifunctor.bimap(dictBitraversable.Bifunctor0())(f)(g)(t));
        };
      };
    };
  };
};

var bifor = function bifor(dictBitraversable) {
  return function (dictApplicative) {
    return function (t) {
      return function (f) {
        return function (g) {
          return bitraverse(dictBitraversable)(dictApplicative)(f)(g)(t);
        };
      };
    };
  };
};

module.exports = {
  Bitraversable: Bitraversable,
  bitraverse: bitraverse,
  bisequence: bisequence,
  bitraverseDefault: bitraverseDefault,
  bisequenceDefault: bisequenceDefault,
  ltraverse: ltraverse,
  rtraverse: rtraverse,
  bifor: bifor,
  lfor: lfor,
  rfor: rfor,
  bitraversableClown: bitraversableClown,
  bitraversableJoker: bitraversableJoker,
  bitraversableFlip: bitraversableFlip,
  bitraversableProduct: bitraversableProduct,
  bitraversableWrap: bitraversableWrap
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Bifoldable/index.js":"../output/Data.Bifoldable/index.js","../Data.Bifunctor/index.js":"../output/Data.Bifunctor/index.js","../Data.Bifunctor.Clown/index.js":"../output/Data.Bifunctor.Clown/index.js","../Data.Bifunctor.Flip/index.js":"../output/Data.Bifunctor.Flip/index.js","../Data.Bifunctor.Joker/index.js":"../output/Data.Bifunctor.Joker/index.js","../Data.Bifunctor.Product/index.js":"../output/Data.Bifunctor.Product/index.js","../Data.Bifunctor.Wrap/index.js":"../output/Data.Bifunctor.Wrap/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Traversable/index.js":"../output/Data.Traversable/index.js"}],"../output/Data.BooleanAlgebra/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Data_HeytingAlgebra = require("../Data.HeytingAlgebra/index.js");

var BooleanAlgebraRecord = function BooleanAlgebraRecord(HeytingAlgebraRecord0) {
  this.HeytingAlgebraRecord0 = HeytingAlgebraRecord0;
};

var BooleanAlgebra = function BooleanAlgebra(HeytingAlgebra0) {
  this.HeytingAlgebra0 = HeytingAlgebra0;
};

var booleanAlgebraUnit = new BooleanAlgebra(function () {
  return Data_HeytingAlgebra.heytingAlgebraUnit;
});
var booleanAlgebraRecordNil = new BooleanAlgebraRecord(function () {
  return Data_HeytingAlgebra.heytingAlgebraRecordNil;
});

var booleanAlgebraRecordCons = function booleanAlgebraRecordCons(dictIsSymbol) {
  return function (dictCons) {
    return function (dictBooleanAlgebraRecord) {
      return function (dictBooleanAlgebra) {
        return new BooleanAlgebraRecord(function () {
          return Data_HeytingAlgebra.heytingAlgebraRecordCons(dictIsSymbol)()(dictBooleanAlgebraRecord.HeytingAlgebraRecord0())(dictBooleanAlgebra.HeytingAlgebra0());
        });
      };
    };
  };
};

var booleanAlgebraRecord = function booleanAlgebraRecord(dictRowToList) {
  return function (dictBooleanAlgebraRecord) {
    return new BooleanAlgebra(function () {
      return Data_HeytingAlgebra.heytingAlgebraRecord()(dictBooleanAlgebraRecord.HeytingAlgebraRecord0());
    });
  };
};

var booleanAlgebraFn = function booleanAlgebraFn(dictBooleanAlgebra) {
  return new BooleanAlgebra(function () {
    return Data_HeytingAlgebra.heytingAlgebraFunction(dictBooleanAlgebra.HeytingAlgebra0());
  });
};

var booleanAlgebraBoolean = new BooleanAlgebra(function () {
  return Data_HeytingAlgebra.heytingAlgebraBoolean;
});
module.exports = {
  BooleanAlgebra: BooleanAlgebra,
  BooleanAlgebraRecord: BooleanAlgebraRecord,
  booleanAlgebraBoolean: booleanAlgebraBoolean,
  booleanAlgebraUnit: booleanAlgebraUnit,
  booleanAlgebraFn: booleanAlgebraFn,
  booleanAlgebraRecord: booleanAlgebraRecord,
  booleanAlgebraRecordNil: booleanAlgebraRecordNil,
  booleanAlgebraRecordCons: booleanAlgebraRecordCons
};
},{"../Data.HeytingAlgebra/index.js":"../output/Data.HeytingAlgebra/index.js"}],"../output/Data.Semigroup.Traversable/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Category = require("../Control.Category/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Monoid_Dual = require("../Data.Monoid.Dual/index.js");

var Data_Monoid_Multiplicative = require("../Data.Monoid.Multiplicative/index.js");

var Data_Semigroup_Foldable = require("../Data.Semigroup.Foldable/index.js");

var Data_Traversable = require("../Data.Traversable/index.js");

var Traversable1 = function Traversable1(Foldable10, _Traversable, sequence1, traverse1) {
  this.Foldable10 = Foldable10;
  this.Traversable1 = _Traversable;
  this.sequence1 = sequence1;
  this.traverse1 = traverse1;
};

var traverse1 = function traverse1(dict) {
  return dict.traverse1;
};

var sequence1Default = function sequence1Default(dictTraversable1) {
  return function (dictApply) {
    return traverse1(dictTraversable1)(dictApply)(Control_Category.identity(Control_Category.categoryFn));
  };
};

var traversableDual = new Traversable1(function () {
  return Data_Semigroup_Foldable.foldableDual;
}, function () {
  return Data_Traversable.traversableDual;
}, function (dictApply) {
  return sequence1Default(traversableDual)(dictApply);
}, function (dictApply) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApply.Functor0())(Data_Monoid_Dual.Dual)(f(v));
    };
  };
});
var traversableMultiplicative = new Traversable1(function () {
  return Data_Semigroup_Foldable.foldableMultiplicative;
}, function () {
  return Data_Traversable.traversableMultiplicative;
}, function (dictApply) {
  return sequence1Default(traversableMultiplicative)(dictApply);
}, function (dictApply) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApply.Functor0())(Data_Monoid_Multiplicative.Multiplicative)(f(v));
    };
  };
});

var sequence1 = function sequence1(dict) {
  return dict.sequence1;
};

var traverse1Default = function traverse1Default(dictTraversable1) {
  return function (dictApply) {
    return function (f) {
      return function (ta) {
        return sequence1(dictTraversable1)(dictApply)(Data_Functor.map(dictTraversable1.Traversable1().Functor0())(f)(ta));
      };
    };
  };
};

module.exports = {
  sequence1: sequence1,
  traverse1: traverse1,
  Traversable1: Traversable1,
  traverse1Default: traverse1Default,
  sequence1Default: sequence1Default,
  traversableDual: traversableDual,
  traversableMultiplicative: traversableMultiplicative
};
},{"../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Monoid.Dual/index.js":"../output/Data.Monoid.Dual/index.js","../Data.Monoid.Multiplicative/index.js":"../output/Data.Monoid.Multiplicative/index.js","../Data.Semigroup.Foldable/index.js":"../output/Data.Semigroup.Foldable/index.js","../Data.Traversable/index.js":"../output/Data.Traversable/index.js"}],"../output/Data.Identity/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Alt = require("../Control.Alt/index.js");

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Comonad = require("../Control.Comonad/index.js");

var Control_Extend = require("../Control.Extend/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Foldable = require("../Data.Foldable/index.js");

var Data_FoldableWithIndex = require("../Data.FoldableWithIndex/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Functor_Invariant = require("../Data.Functor.Invariant/index.js");

var Data_FunctorWithIndex = require("../Data.FunctorWithIndex/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Semigroup_Foldable = require("../Data.Semigroup.Foldable/index.js");

var Data_Semigroup_Traversable = require("../Data.Semigroup.Traversable/index.js");

var Data_Show = require("../Data.Show/index.js");

var Data_Traversable = require("../Data.Traversable/index.js");

var Data_TraversableWithIndex = require("../Data.TraversableWithIndex/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Identity = function Identity(x) {
  return x;
};

var showIdentity = function showIdentity(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(Identity " + (Data_Show.show(dictShow)(v) + ")");
  });
};

var semiringIdentity = function semiringIdentity(dictSemiring) {
  return dictSemiring;
};

var semigroupIdenity = function semigroupIdenity(dictSemigroup) {
  return dictSemigroup;
};

var ringIdentity = function ringIdentity(dictRing) {
  return dictRing;
};

var ordIdentity = function ordIdentity(dictOrd) {
  return dictOrd;
};

var newtypeIdentity = new Data_Newtype.Newtype(function (n) {
  return n;
}, Identity);

var monoidIdentity = function monoidIdentity(dictMonoid) {
  return dictMonoid;
};

var lazyIdentity = function lazyIdentity(dictLazy) {
  return dictLazy;
};

var heytingAlgebraIdentity = function heytingAlgebraIdentity(dictHeytingAlgebra) {
  return dictHeytingAlgebra;
};

var functorIdentity = new Data_Functor.Functor(function (f) {
  return function (m) {
    return f(m);
  };
});
var functorWithIndexIdentity = new Data_FunctorWithIndex.FunctorWithIndex(function () {
  return functorIdentity;
}, function (f) {
  return function (v) {
    return f(Data_Unit.unit)(v);
  };
});
var invariantIdentity = new Data_Functor_Invariant.Invariant(Data_Functor_Invariant.imapF(functorIdentity));
var foldableIdentity = new Data_Foldable.Foldable(function (dictMonoid) {
  return function (f) {
    return function (v) {
      return f(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(z)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(v)(z);
    };
  };
});
var foldableWithIndexIdentity = new Data_FoldableWithIndex.FoldableWithIndex(function () {
  return foldableIdentity;
}, function (dictMonoid) {
  return function (f) {
    return function (v) {
      return f(Data_Unit.unit)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(Data_Unit.unit)(z)(v);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(Data_Unit.unit)(v)(z);
    };
  };
});
var traversableIdentity = new Data_Traversable.Traversable(function () {
  return foldableIdentity;
}, function () {
  return functorIdentity;
}, function (dictApplicative) {
  return function (v) {
    return Data_Functor.map(dictApplicative.Apply0().Functor0())(Identity)(v);
  };
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Identity)(f(v));
    };
  };
});
var traversableWithIndexIdentity = new Data_TraversableWithIndex.TraversableWithIndex(function () {
  return foldableWithIndexIdentity;
}, function () {
  return functorWithIndexIdentity;
}, function () {
  return traversableIdentity;
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Identity)(f(Data_Unit.unit)(v));
    };
  };
});
var foldable1Identity = new Data_Semigroup_Foldable.Foldable1(function () {
  return foldableIdentity;
}, function (dictSemigroup) {
  return function (v) {
    return v;
  };
}, function (dictSemigroup) {
  return function (f) {
    return function (v) {
      return f(v);
    };
  };
});
var traversable1Identity = new Data_Semigroup_Traversable.Traversable1(function () {
  return foldable1Identity;
}, function () {
  return traversableIdentity;
}, function (dictApply) {
  return function (v) {
    return Data_Functor.map(dictApply.Functor0())(Identity)(v);
  };
}, function (dictApply) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApply.Functor0())(Identity)(f(v));
    };
  };
});
var extendIdentity = new Control_Extend.Extend(function () {
  return functorIdentity;
}, function (f) {
  return function (m) {
    return f(m);
  };
});

var euclideanRingIdentity = function euclideanRingIdentity(dictEuclideanRing) {
  return dictEuclideanRing;
};

var eqIdentity = function eqIdentity(dictEq) {
  return dictEq;
};

var eq1Identity = new Data_Eq.Eq1(function (dictEq) {
  return Data_Eq.eq(eqIdentity(dictEq));
});
var ord1Identity = new Data_Ord.Ord1(function () {
  return eq1Identity;
}, function (dictOrd) {
  return Data_Ord.compare(ordIdentity(dictOrd));
});
var comonadIdentity = new Control_Comonad.Comonad(function () {
  return extendIdentity;
}, function (v) {
  return v;
});

var commutativeRingIdentity = function commutativeRingIdentity(dictCommutativeRing) {
  return dictCommutativeRing;
};

var boundedIdentity = function boundedIdentity(dictBounded) {
  return dictBounded;
};

var booleanAlgebraIdentity = function booleanAlgebraIdentity(dictBooleanAlgebra) {
  return dictBooleanAlgebra;
};

var applyIdentity = new Control_Apply.Apply(function () {
  return functorIdentity;
}, function (v) {
  return function (v1) {
    return v(v1);
  };
});
var bindIdentity = new Control_Bind.Bind(function () {
  return applyIdentity;
}, function (v) {
  return function (f) {
    return f(v);
  };
});
var applicativeIdentity = new Control_Applicative.Applicative(function () {
  return applyIdentity;
}, Identity);
var monadIdentity = new Control_Monad.Monad(function () {
  return applicativeIdentity;
}, function () {
  return bindIdentity;
});
var altIdentity = new Control_Alt.Alt(function () {
  return functorIdentity;
}, function (x) {
  return function (v) {
    return x;
  };
});
module.exports = {
  Identity: Identity,
  newtypeIdentity: newtypeIdentity,
  eqIdentity: eqIdentity,
  ordIdentity: ordIdentity,
  boundedIdentity: boundedIdentity,
  heytingAlgebraIdentity: heytingAlgebraIdentity,
  booleanAlgebraIdentity: booleanAlgebraIdentity,
  semigroupIdenity: semigroupIdenity,
  monoidIdentity: monoidIdentity,
  semiringIdentity: semiringIdentity,
  euclideanRingIdentity: euclideanRingIdentity,
  ringIdentity: ringIdentity,
  commutativeRingIdentity: commutativeRingIdentity,
  lazyIdentity: lazyIdentity,
  showIdentity: showIdentity,
  eq1Identity: eq1Identity,
  ord1Identity: ord1Identity,
  functorIdentity: functorIdentity,
  functorWithIndexIdentity: functorWithIndexIdentity,
  invariantIdentity: invariantIdentity,
  altIdentity: altIdentity,
  applyIdentity: applyIdentity,
  applicativeIdentity: applicativeIdentity,
  bindIdentity: bindIdentity,
  monadIdentity: monadIdentity,
  extendIdentity: extendIdentity,
  comonadIdentity: comonadIdentity,
  foldableIdentity: foldableIdentity,
  foldable1Identity: foldable1Identity,
  foldableWithIndexIdentity: foldableWithIndexIdentity,
  traversableIdentity: traversableIdentity,
  traversable1Identity: traversable1Identity,
  traversableWithIndexIdentity: traversableWithIndexIdentity
};
},{"../Control.Alt/index.js":"../output/Control.Alt/index.js","../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Comonad/index.js":"../output/Control.Comonad/index.js","../Control.Extend/index.js":"../output/Control.Extend/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Foldable/index.js":"../output/Data.Foldable/index.js","../Data.FoldableWithIndex/index.js":"../output/Data.FoldableWithIndex/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Functor.Invariant/index.js":"../output/Data.Functor.Invariant/index.js","../Data.FunctorWithIndex/index.js":"../output/Data.FunctorWithIndex/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Semigroup.Foldable/index.js":"../output/Data.Semigroup.Foldable/index.js","../Data.Semigroup.Traversable/index.js":"../output/Data.Semigroup.Traversable/index.js","../Data.Show/index.js":"../output/Data.Show/index.js","../Data.Traversable/index.js":"../output/Data.Traversable/index.js","../Data.TraversableWithIndex/index.js":"../output/Data.TraversableWithIndex/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.Distributive/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Category = require("../Control.Category/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Identity = require("../Data.Identity/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Distributive = function Distributive(Functor0, collect, distribute) {
  this.Functor0 = Functor0;
  this.collect = collect;
  this.distribute = distribute;
};

var distributiveIdentity = new Distributive(function () {
  return Data_Identity.functorIdentity;
}, function (dictFunctor) {
  return function (f) {
    var $11 = Data_Functor.map(dictFunctor)(function () {
      var $13 = Data_Newtype.unwrap(Data_Identity.newtypeIdentity);
      return function ($14) {
        return $13(f($14));
      };
    }());
    return function ($12) {
      return Data_Identity.Identity($11($12));
    };
  };
}, function (dictFunctor) {
  var $15 = Data_Functor.map(dictFunctor)(Data_Newtype.unwrap(Data_Identity.newtypeIdentity));
  return function ($16) {
    return Data_Identity.Identity($15($16));
  };
});

var distribute = function distribute(dict) {
  return dict.distribute;
};

var distributiveFunction = new Distributive(function () {
  return Data_Functor.functorFn;
}, function (dictFunctor) {
  return function (f) {
    var $17 = distribute(distributiveFunction)(dictFunctor);
    var $18 = Data_Functor.map(dictFunctor)(f);
    return function ($19) {
      return $17($18($19));
    };
  };
}, function (dictFunctor) {
  return function (a) {
    return function (e) {
      return Data_Functor.map(dictFunctor)(function (v) {
        return v(e);
      })(a);
    };
  };
});

var cotraverse = function cotraverse(dictDistributive) {
  return function (dictFunctor) {
    return function (f) {
      var $20 = Data_Functor.map(dictDistributive.Functor0())(f);
      var $21 = distribute(dictDistributive)(dictFunctor);
      return function ($22) {
        return $20($21($22));
      };
    };
  };
};

var collectDefault = function collectDefault(dictDistributive) {
  return function (dictFunctor) {
    return function (f) {
      var $23 = distribute(dictDistributive)(dictFunctor);
      var $24 = Data_Functor.map(dictFunctor)(f);
      return function ($25) {
        return $23($24($25));
      };
    };
  };
};

var collect = function collect(dict) {
  return dict.collect;
};

var distributeDefault = function distributeDefault(dictDistributive) {
  return function (dictFunctor) {
    return collect(dictDistributive)(dictFunctor)(Control_Category.identity(Control_Category.categoryFn));
  };
};

module.exports = {
  collect: collect,
  distribute: distribute,
  Distributive: Distributive,
  distributeDefault: distributeDefault,
  collectDefault: collectDefault,
  cotraverse: cotraverse,
  distributiveIdentity: distributiveIdentity,
  distributiveFunction: distributiveFunction
};
},{"../Control.Category/index.js":"../output/Control.Category/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Identity/index.js":"../output/Data.Identity/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js"}],"../output/Type.Equality/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var TypeEquals = function TypeEquals(from, to) {
  this.from = from;
  this.to = to;
};

var to = function to(dict) {
  return dict.to;
};

var refl = new TypeEquals(function (a) {
  return a;
}, function (a) {
  return a;
});

var from = function from(dict) {
  return dict.from;
};

module.exports = {
  TypeEquals: TypeEquals,
  to: to,
  from: from,
  refl: refl
};
},{}],"../output/Data.Tuple/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Biapplicative = require("../Control.Biapplicative/index.js");

var Control_Biapply = require("../Control.Biapply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Comonad = require("../Control.Comonad/index.js");

var Control_Extend = require("../Control.Extend/index.js");

var Control_Lazy = require("../Control.Lazy/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Control_Semigroupoid = require("../Control.Semigroupoid/index.js");

var Data_Bifoldable = require("../Data.Bifoldable/index.js");

var Data_Bifunctor = require("../Data.Bifunctor/index.js");

var Data_Bitraversable = require("../Data.Bitraversable/index.js");

var Data_BooleanAlgebra = require("../Data.BooleanAlgebra/index.js");

var Data_Bounded = require("../Data.Bounded/index.js");

var Data_CommutativeRing = require("../Data.CommutativeRing/index.js");

var Data_Distributive = require("../Data.Distributive/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Foldable = require("../Data.Foldable/index.js");

var Data_FoldableWithIndex = require("../Data.FoldableWithIndex/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Functor_Invariant = require("../Data.Functor.Invariant/index.js");

var Data_FunctorWithIndex = require("../Data.FunctorWithIndex/index.js");

var Data_HeytingAlgebra = require("../Data.HeytingAlgebra/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Maybe_First = require("../Data.Maybe.First/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Ordering = require("../Data.Ordering/index.js");

var Data_Ring = require("../Data.Ring/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Semigroup_Foldable = require("../Data.Semigroup.Foldable/index.js");

var Data_Semigroup_Traversable = require("../Data.Semigroup.Traversable/index.js");

var Data_Semiring = require("../Data.Semiring/index.js");

var Data_Show = require("../Data.Show/index.js");

var Data_Traversable = require("../Data.Traversable/index.js");

var Data_TraversableWithIndex = require("../Data.TraversableWithIndex/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Type_Equality = require("../Type.Equality/index.js");

var Tuple = function () {
  function Tuple(value0, value1) {
    this.value0 = value0;
    this.value1 = value1;
  }

  ;

  Tuple.create = function (value0) {
    return function (value1) {
      return new Tuple(value0, value1);
    };
  };

  return Tuple;
}();

var uncurry = function uncurry(f) {
  return function (v) {
    return f(v.value0)(v.value1);
  };
};

var swap = function swap(v) {
  return new Tuple(v.value1, v.value0);
};

var snd = function snd(v) {
  return v.value1;
};

var showTuple = function showTuple(dictShow) {
  return function (dictShow1) {
    return new Data_Show.Show(function (v) {
      return "(Tuple " + (Data_Show.show(dictShow)(v.value0) + (" " + (Data_Show.show(dictShow1)(v.value1) + ")")));
    });
  };
};

var semiringTuple = function semiringTuple(dictSemiring) {
  return function (dictSemiring1) {
    return new Data_Semiring.Semiring(function (v) {
      return function (v1) {
        return new Tuple(Data_Semiring.add(dictSemiring)(v.value0)(v1.value0), Data_Semiring.add(dictSemiring1)(v.value1)(v1.value1));
      };
    }, function (v) {
      return function (v1) {
        return new Tuple(Data_Semiring.mul(dictSemiring)(v.value0)(v1.value0), Data_Semiring.mul(dictSemiring1)(v.value1)(v1.value1));
      };
    }, new Tuple(Data_Semiring.one(dictSemiring), Data_Semiring.one(dictSemiring1)), new Tuple(Data_Semiring.zero(dictSemiring), Data_Semiring.zero(dictSemiring1)));
  };
};

var semigroupoidTuple = new Control_Semigroupoid.Semigroupoid(function (v) {
  return function (v1) {
    return new Tuple(v1.value0, v.value1);
  };
});

var semigroupTuple = function semigroupTuple(dictSemigroup) {
  return function (dictSemigroup1) {
    return new Data_Semigroup.Semigroup(function (v) {
      return function (v1) {
        return new Tuple(Data_Semigroup.append(dictSemigroup)(v.value0)(v1.value0), Data_Semigroup.append(dictSemigroup1)(v.value1)(v1.value1));
      };
    });
  };
};

var ringTuple = function ringTuple(dictRing) {
  return function (dictRing1) {
    return new Data_Ring.Ring(function () {
      return semiringTuple(dictRing.Semiring0())(dictRing1.Semiring0());
    }, function (v) {
      return function (v1) {
        return new Tuple(Data_Ring.sub(dictRing)(v.value0)(v1.value0), Data_Ring.sub(dictRing1)(v.value1)(v1.value1));
      };
    });
  };
};

var monoidTuple = function monoidTuple(dictMonoid) {
  return function (dictMonoid1) {
    return new Data_Monoid.Monoid(function () {
      return semigroupTuple(dictMonoid.Semigroup0())(dictMonoid1.Semigroup0());
    }, new Tuple(Data_Monoid.mempty(dictMonoid), Data_Monoid.mempty(dictMonoid1)));
  };
};

var lookup = function lookup(dictFoldable) {
  return function (dictEq) {
    return function (a) {
      var $312 = Data_Newtype.unwrap(Data_Maybe_First.newtypeFirst);
      var $313 = Data_Foldable.foldMap(dictFoldable)(Data_Maybe_First.monoidFirst)(function (v) {
        var $163 = Data_Eq.eq(dictEq)(a)(v.value0);

        if ($163) {
          return new Data_Maybe.Just(v.value1);
        }

        ;
        return Data_Maybe.Nothing.value;
      });
      return function ($314) {
        return $312($313($314));
      };
    };
  };
};

var heytingAlgebraTuple = function heytingAlgebraTuple(dictHeytingAlgebra) {
  return function (dictHeytingAlgebra1) {
    return new Data_HeytingAlgebra.HeytingAlgebra(function (v) {
      return function (v1) {
        return new Tuple(Data_HeytingAlgebra.conj(dictHeytingAlgebra)(v.value0)(v1.value0), Data_HeytingAlgebra.conj(dictHeytingAlgebra1)(v.value1)(v1.value1));
      };
    }, function (v) {
      return function (v1) {
        return new Tuple(Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v.value0)(v1.value0), Data_HeytingAlgebra.disj(dictHeytingAlgebra1)(v.value1)(v1.value1));
      };
    }, new Tuple(Data_HeytingAlgebra.ff(dictHeytingAlgebra), Data_HeytingAlgebra.ff(dictHeytingAlgebra1)), function (v) {
      return function (v1) {
        return new Tuple(Data_HeytingAlgebra.implies(dictHeytingAlgebra)(v.value0)(v1.value0), Data_HeytingAlgebra.implies(dictHeytingAlgebra1)(v.value1)(v1.value1));
      };
    }, function (v) {
      return new Tuple(Data_HeytingAlgebra.not(dictHeytingAlgebra)(v.value0), Data_HeytingAlgebra.not(dictHeytingAlgebra1)(v.value1));
    }, new Tuple(Data_HeytingAlgebra.tt(dictHeytingAlgebra), Data_HeytingAlgebra.tt(dictHeytingAlgebra1)));
  };
};

var functorTuple = new Data_Functor.Functor(function (f) {
  return function (m) {
    return new Tuple(m.value0, f(m.value1));
  };
});
var functorWithIndexTuple = new Data_FunctorWithIndex.FunctorWithIndex(function () {
  return functorTuple;
}, function (f) {
  return Data_Functor.map(functorTuple)(f(Data_Unit.unit));
});
var invariantTuple = new Data_Functor_Invariant.Invariant(Data_Functor_Invariant.imapF(functorTuple));

var fst = function fst(v) {
  return v.value0;
};

var lazyTuple = function lazyTuple(dictLazy) {
  return function (dictLazy1) {
    return new Control_Lazy.Lazy(function (f) {
      return new Tuple(Control_Lazy.defer(dictLazy)(function (v) {
        return fst(f(Data_Unit.unit));
      }), Control_Lazy.defer(dictLazy1)(function (v) {
        return snd(f(Data_Unit.unit));
      }));
    });
  };
};

var foldableTuple = new Data_Foldable.Foldable(function (dictMonoid) {
  return function (f) {
    return function (v) {
      return f(v.value1);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(z)(v.value1);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(v.value1)(z);
    };
  };
});
var foldableWithIndexTuple = new Data_FoldableWithIndex.FoldableWithIndex(function () {
  return foldableTuple;
}, function (dictMonoid) {
  return function (f) {
    return function (v) {
      return f(Data_Unit.unit)(v.value1);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(Data_Unit.unit)(z)(v.value1);
    };
  };
}, function (f) {
  return function (z) {
    return function (v) {
      return f(Data_Unit.unit)(v.value1)(z);
    };
  };
});
var traversableTuple = new Data_Traversable.Traversable(function () {
  return foldableTuple;
}, function () {
  return functorTuple;
}, function (dictApplicative) {
  return function (v) {
    return Data_Functor.map(dictApplicative.Apply0().Functor0())(Tuple.create(v.value0))(v.value1);
  };
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Tuple.create(v.value0))(f(v.value1));
    };
  };
});
var traversableWithIndexTuple = new Data_TraversableWithIndex.TraversableWithIndex(function () {
  return foldableWithIndexTuple;
}, function () {
  return functorWithIndexTuple;
}, function () {
  return traversableTuple;
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(Tuple.create(v.value0))(f(Data_Unit.unit)(v.value1));
    };
  };
});
var foldable1Tuple = new Data_Semigroup_Foldable.Foldable1(function () {
  return foldableTuple;
}, function (dictSemigroup) {
  return function (v) {
    return v.value1;
  };
}, function (dictSemigroup) {
  return function (f) {
    return function (v) {
      return f(v.value1);
    };
  };
});
var traversable1Tuple = new Data_Semigroup_Traversable.Traversable1(function () {
  return foldable1Tuple;
}, function () {
  return traversableTuple;
}, function (dictApply) {
  return function (v) {
    return Data_Functor.map(dictApply.Functor0())(Tuple.create(v.value0))(v.value1);
  };
}, function (dictApply) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApply.Functor0())(Tuple.create(v.value0))(f(v.value1));
    };
  };
});
var extendTuple = new Control_Extend.Extend(function () {
  return functorTuple;
}, function (f) {
  return function (v) {
    return new Tuple(v.value0, f(v));
  };
});

var eqTuple = function eqTuple(dictEq) {
  return function (dictEq1) {
    return new Data_Eq.Eq(function (x) {
      return function (y) {
        return Data_Eq.eq(dictEq)(x.value0)(y.value0) && Data_Eq.eq(dictEq1)(x.value1)(y.value1);
      };
    });
  };
};

var ordTuple = function ordTuple(dictOrd) {
  return function (dictOrd1) {
    return new Data_Ord.Ord(function () {
      return eqTuple(dictOrd.Eq0())(dictOrd1.Eq0());
    }, function (x) {
      return function (y) {
        var v = Data_Ord.compare(dictOrd)(x.value0)(y.value0);

        if (v instanceof Data_Ordering.LT) {
          return Data_Ordering.LT.value;
        }

        ;

        if (v instanceof Data_Ordering.GT) {
          return Data_Ordering.GT.value;
        }

        ;
        return Data_Ord.compare(dictOrd1)(x.value1)(y.value1);
      };
    });
  };
};

var eq1Tuple = function eq1Tuple(dictEq) {
  return new Data_Eq.Eq1(function (dictEq1) {
    return Data_Eq.eq(eqTuple(dictEq)(dictEq1));
  });
};

var ord1Tuple = function ord1Tuple(dictOrd) {
  return new Data_Ord.Ord1(function () {
    return eq1Tuple(dictOrd.Eq0());
  }, function (dictOrd1) {
    return Data_Ord.compare(ordTuple(dictOrd)(dictOrd1));
  });
};

var distributiveTuple = function distributiveTuple(dictTypeEquals) {
  return new Data_Distributive.Distributive(function () {
    return functorTuple;
  }, function (dictFunctor) {
    return Data_Distributive.collectDefault(distributiveTuple(dictTypeEquals))(dictFunctor);
  }, function (dictFunctor) {
    var $315 = Tuple.create(Type_Equality.from(dictTypeEquals)(Data_Unit.unit));
    var $316 = Data_Functor.map(dictFunctor)(snd);
    return function ($317) {
      return $315($316($317));
    };
  });
};

var curry = function curry(f) {
  return function (a) {
    return function (b) {
      return f(new Tuple(a, b));
    };
  };
};

var comonadTuple = new Control_Comonad.Comonad(function () {
  return extendTuple;
}, snd);

var commutativeRingTuple = function commutativeRingTuple(dictCommutativeRing) {
  return function (dictCommutativeRing1) {
    return new Data_CommutativeRing.CommutativeRing(function () {
      return ringTuple(dictCommutativeRing.Ring0())(dictCommutativeRing1.Ring0());
    });
  };
};

var boundedTuple = function boundedTuple(dictBounded) {
  return function (dictBounded1) {
    return new Data_Bounded.Bounded(function () {
      return ordTuple(dictBounded.Ord0())(dictBounded1.Ord0());
    }, new Tuple(Data_Bounded.bottom(dictBounded), Data_Bounded.bottom(dictBounded1)), new Tuple(Data_Bounded.top(dictBounded), Data_Bounded.top(dictBounded1)));
  };
};

var booleanAlgebraTuple = function booleanAlgebraTuple(dictBooleanAlgebra) {
  return function (dictBooleanAlgebra1) {
    return new Data_BooleanAlgebra.BooleanAlgebra(function () {
      return heytingAlgebraTuple(dictBooleanAlgebra.HeytingAlgebra0())(dictBooleanAlgebra1.HeytingAlgebra0());
    });
  };
};

var bifunctorTuple = new Data_Bifunctor.Bifunctor(function (f) {
  return function (g) {
    return function (v) {
      return new Tuple(f(v.value0), g(v.value1));
    };
  };
});
var bifoldableTuple = new Data_Bifoldable.Bifoldable(function (dictMonoid) {
  return function (f) {
    return function (g) {
      return function (v) {
        return Data_Semigroup.append(dictMonoid.Semigroup0())(f(v.value0))(g(v.value1));
      };
    };
  };
}, function (f) {
  return function (g) {
    return function (z) {
      return function (v) {
        return g(f(z)(v.value0))(v.value1);
      };
    };
  };
}, function (f) {
  return function (g) {
    return function (z) {
      return function (v) {
        return f(v.value0)(g(v.value1)(z));
      };
    };
  };
});
var bitraversableTuple = new Data_Bitraversable.Bitraversable(function () {
  return bifoldableTuple;
}, function () {
  return bifunctorTuple;
}, function (dictApplicative) {
  return function (v) {
    return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map(dictApplicative.Apply0().Functor0())(Tuple.create)(v.value0))(v.value1);
  };
}, function (dictApplicative) {
  return function (f) {
    return function (g) {
      return function (v) {
        return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map(dictApplicative.Apply0().Functor0())(Tuple.create)(f(v.value0)))(g(v.value1));
      };
    };
  };
});
var biapplyTuple = new Control_Biapply.Biapply(function () {
  return bifunctorTuple;
}, function (v) {
  return function (v1) {
    return new Tuple(v.value0(v1.value0), v.value1(v1.value1));
  };
});
var biapplicativeTuple = new Control_Biapplicative.Biapplicative(function () {
  return biapplyTuple;
}, Tuple.create);

var applyTuple = function applyTuple(dictSemigroup) {
  return new Control_Apply.Apply(function () {
    return functorTuple;
  }, function (v) {
    return function (v1) {
      return new Tuple(Data_Semigroup.append(dictSemigroup)(v.value0)(v1.value0), v.value1(v1.value1));
    };
  });
};

var bindTuple = function bindTuple(dictSemigroup) {
  return new Control_Bind.Bind(function () {
    return applyTuple(dictSemigroup);
  }, function (v) {
    return function (f) {
      var v1 = f(v.value1);
      return new Tuple(Data_Semigroup.append(dictSemigroup)(v.value0)(v1.value0), v1.value1);
    };
  });
};

var applicativeTuple = function applicativeTuple(dictMonoid) {
  return new Control_Applicative.Applicative(function () {
    return applyTuple(dictMonoid.Semigroup0());
  }, Tuple.create(Data_Monoid.mempty(dictMonoid)));
};

var monadTuple = function monadTuple(dictMonoid) {
  return new Control_Monad.Monad(function () {
    return applicativeTuple(dictMonoid);
  }, function () {
    return bindTuple(dictMonoid.Semigroup0());
  });
};

module.exports = {
  Tuple: Tuple,
  fst: fst,
  snd: snd,
  curry: curry,
  uncurry: uncurry,
  swap: swap,
  lookup: lookup,
  showTuple: showTuple,
  eqTuple: eqTuple,
  eq1Tuple: eq1Tuple,
  ordTuple: ordTuple,
  ord1Tuple: ord1Tuple,
  boundedTuple: boundedTuple,
  semigroupoidTuple: semigroupoidTuple,
  semigroupTuple: semigroupTuple,
  monoidTuple: monoidTuple,
  semiringTuple: semiringTuple,
  ringTuple: ringTuple,
  commutativeRingTuple: commutativeRingTuple,
  heytingAlgebraTuple: heytingAlgebraTuple,
  booleanAlgebraTuple: booleanAlgebraTuple,
  functorTuple: functorTuple,
  functorWithIndexTuple: functorWithIndexTuple,
  invariantTuple: invariantTuple,
  bifunctorTuple: bifunctorTuple,
  applyTuple: applyTuple,
  biapplyTuple: biapplyTuple,
  applicativeTuple: applicativeTuple,
  biapplicativeTuple: biapplicativeTuple,
  bindTuple: bindTuple,
  monadTuple: monadTuple,
  extendTuple: extendTuple,
  comonadTuple: comonadTuple,
  lazyTuple: lazyTuple,
  foldableTuple: foldableTuple,
  foldable1Tuple: foldable1Tuple,
  foldableWithIndexTuple: foldableWithIndexTuple,
  bifoldableTuple: bifoldableTuple,
  traversableTuple: traversableTuple,
  traversable1Tuple: traversable1Tuple,
  traversableWithIndexTuple: traversableWithIndexTuple,
  bitraversableTuple: bitraversableTuple,
  distributiveTuple: distributiveTuple
};
},{"../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Biapplicative/index.js":"../output/Control.Biapplicative/index.js","../Control.Biapply/index.js":"../output/Control.Biapply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Comonad/index.js":"../output/Control.Comonad/index.js","../Control.Extend/index.js":"../output/Control.Extend/index.js","../Control.Lazy/index.js":"../output/Control.Lazy/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Control.Semigroupoid/index.js":"../output/Control.Semigroupoid/index.js","../Data.Bifoldable/index.js":"../output/Data.Bifoldable/index.js","../Data.Bifunctor/index.js":"../output/Data.Bifunctor/index.js","../Data.Bitraversable/index.js":"../output/Data.Bitraversable/index.js","../Data.BooleanAlgebra/index.js":"../output/Data.BooleanAlgebra/index.js","../Data.Bounded/index.js":"../output/Data.Bounded/index.js","../Data.CommutativeRing/index.js":"../output/Data.CommutativeRing/index.js","../Data.Distributive/index.js":"../output/Data.Distributive/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Foldable/index.js":"../output/Data.Foldable/index.js","../Data.FoldableWithIndex/index.js":"../output/Data.FoldableWithIndex/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Functor.Invariant/index.js":"../output/Data.Functor.Invariant/index.js","../Data.FunctorWithIndex/index.js":"../output/Data.FunctorWithIndex/index.js","../Data.HeytingAlgebra/index.js":"../output/Data.HeytingAlgebra/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Maybe.First/index.js":"../output/Data.Maybe.First/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Ordering/index.js":"../output/Data.Ordering/index.js","../Data.Ring/index.js":"../output/Data.Ring/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Semigroup.Foldable/index.js":"../output/Data.Semigroup.Foldable/index.js","../Data.Semigroup.Traversable/index.js":"../output/Data.Semigroup.Traversable/index.js","../Data.Semiring/index.js":"../output/Data.Semiring/index.js","../Data.Show/index.js":"../output/Data.Show/index.js","../Data.Traversable/index.js":"../output/Data.Traversable/index.js","../Data.TraversableWithIndex/index.js":"../output/Data.TraversableWithIndex/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js","../Type.Equality/index.js":"../output/Type.Equality/index.js"}],"../output/Data.Unfoldable/foreign.js":[function(require,module,exports) {
"use strict";

exports.unfoldrArrayImpl = function (isNothing) {
  return function (fromJust) {
    return function (fst) {
      return function (snd) {
        return function (f) {
          return function (b) {
            var result = [];
            var value = b;

            while (true) {
              // eslint-disable-line no-constant-condition
              var maybe = f(value);
              if (isNothing(maybe)) return result;
              var tuple = fromJust(maybe);
              result.push(fst(tuple));
              value = snd(tuple);
            }
          };
        };
      };
    };
  };
};
},{}],"../output/Data.Unfoldable1/foreign.js":[function(require,module,exports) {
"use strict";

exports.unfoldr1ArrayImpl = function (isNothing) {
  return function (fromJust) {
    return function (fst) {
      return function (snd) {
        return function (f) {
          return function (b) {
            var result = [];
            var value = b;

            while (true) {
              // eslint-disable-line no-constant-condition
              var tuple = f(value);
              result.push(fst(tuple));
              var maybe = snd(tuple);
              if (isNothing(maybe)) return result;
              value = fromJust(maybe);
            }
          };
        };
      };
    };
  };
};
},{}],"../output/Data.Unfoldable1/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Boolean = require("../Data.Boolean/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Semigroup_Traversable = require("../Data.Semigroup.Traversable/index.js");

var Data_Tuple = require("../Data.Tuple/index.js");

var Unfoldable1 = function Unfoldable1(unfoldr1) {
  this.unfoldr1 = unfoldr1;
};

var unfoldr1 = function unfoldr1(dict) {
  return dict.unfoldr1;
};

var unfoldable1Maybe = new Unfoldable1(function (f) {
  return function (b) {
    return new Data_Maybe.Just(Data_Tuple.fst(f(b)));
  };
});
var unfoldable1Array = new Unfoldable1($foreign.unfoldr1ArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));

var replicate1 = function replicate1(dictUnfoldable1) {
  return function (n) {
    return function (v) {
      var step = function step(i) {
        if (i <= 0) {
          return new Data_Tuple.Tuple(v, Data_Maybe.Nothing.value);
        }

        ;

        if (Data_Boolean.otherwise) {
          return new Data_Tuple.Tuple(v, new Data_Maybe.Just(i - 1 | 0));
        }

        ;
        throw new Error("Failed pattern match at Data.Unfoldable1 (line 67, column 5 - line 67, column 39): " + [i.constructor.name]);
      };

      return unfoldr1(dictUnfoldable1)(step)(n - 1 | 0);
    };
  };
};

var replicate1A = function replicate1A(dictApply) {
  return function (dictUnfoldable1) {
    return function (dictTraversable1) {
      return function (n) {
        return function (m) {
          return Data_Semigroup_Traversable.sequence1(dictTraversable1)(dictApply)(replicate1(dictUnfoldable1)(n)(m));
        };
      };
    };
  };
};

var singleton = function singleton(dictUnfoldable1) {
  return replicate1(dictUnfoldable1)(1);
};

var range = function range(dictUnfoldable1) {
  return function (start) {
    return function (end) {
      var go = function go(delta) {
        return function (i) {
          var i$prime = i + delta | 0;
          return new Data_Tuple.Tuple(i, function () {
            var $8 = i === end;

            if ($8) {
              return Data_Maybe.Nothing.value;
            }

            ;
            return new Data_Maybe.Just(i$prime);
          }());
        };
      };

      var delta = function () {
        var $9 = end >= start;

        if ($9) {
          return 1;
        }

        ;
        return -1 | 0;
      }();

      return unfoldr1(dictUnfoldable1)(go(delta))(start);
    };
  };
};

module.exports = {
  Unfoldable1: Unfoldable1,
  unfoldr1: unfoldr1,
  replicate1: replicate1,
  replicate1A: replicate1A,
  singleton: singleton,
  range: range,
  unfoldable1Array: unfoldable1Array,
  unfoldable1Maybe: unfoldable1Maybe
};
},{"./foreign.js":"../output/Data.Unfoldable1/foreign.js","../Data.Boolean/index.js":"../output/Data.Boolean/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Semigroup.Traversable/index.js":"../output/Data.Semigroup.Traversable/index.js","../Data.Tuple/index.js":"../output/Data.Tuple/index.js"}],"../output/Data.Unfoldable/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Function = require("../Data.Function/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Traversable = require("../Data.Traversable/index.js");

var Data_Tuple = require("../Data.Tuple/index.js");

var Data_Unfoldable1 = require("../Data.Unfoldable1/index.js");

var Data_Unit = require("../Data.Unit/index.js");

var Unfoldable = function Unfoldable(Unfoldable10, unfoldr) {
  this.Unfoldable10 = Unfoldable10;
  this.unfoldr = unfoldr;
};

var unfoldr = function unfoldr(dict) {
  return dict.unfoldr;
};

var unfoldableMaybe = new Unfoldable(function () {
  return Data_Unfoldable1.unfoldable1Maybe;
}, function (f) {
  return function (b) {
    return Data_Functor.map(Data_Maybe.functorMaybe)(Data_Tuple.fst)(f(b));
  };
});
var unfoldableArray = new Unfoldable(function () {
  return Data_Unfoldable1.unfoldable1Array;
}, $foreign.unfoldrArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));

var replicate = function replicate(dictUnfoldable) {
  return function (n) {
    return function (v) {
      var step = function step(i) {
        var $7 = i <= 0;

        if ($7) {
          return Data_Maybe.Nothing.value;
        }

        ;
        return new Data_Maybe.Just(new Data_Tuple.Tuple(v, i - 1 | 0));
      };

      return unfoldr(dictUnfoldable)(step)(n);
    };
  };
};

var replicateA = function replicateA(dictApplicative) {
  return function (dictUnfoldable) {
    return function (dictTraversable) {
      return function (n) {
        return function (m) {
          return Data_Traversable.sequence(dictTraversable)(dictApplicative)(replicate(dictUnfoldable)(n)(m));
        };
      };
    };
  };
};

var none = function none(dictUnfoldable) {
  return unfoldr(dictUnfoldable)(Data_Function["const"](Data_Maybe.Nothing.value))(Data_Unit.unit);
};

var fromMaybe = function fromMaybe(dictUnfoldable) {
  return unfoldr(dictUnfoldable)(function (b) {
    return Data_Functor.map(Data_Maybe.functorMaybe)(Data_Function.flip(Data_Tuple.Tuple.create)(Data_Maybe.Nothing.value))(b);
  });
};

module.exports = {
  Unfoldable: Unfoldable,
  unfoldr: unfoldr,
  replicate: replicate,
  replicateA: replicateA,
  none: none,
  fromMaybe: fromMaybe,
  unfoldableArray: unfoldableArray,
  unfoldableMaybe: unfoldableMaybe
};
},{"./foreign.js":"../output/Data.Unfoldable/foreign.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Traversable/index.js":"../output/Data.Traversable/index.js","../Data.Tuple/index.js":"../output/Data.Tuple/index.js","../Data.Unfoldable1/index.js":"../output/Data.Unfoldable1/index.js","../Data.Unit/index.js":"../output/Data.Unit/index.js"}],"../output/Data.NonEmpty/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Alt = require("../Control.Alt/index.js");

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Category = require("../Control.Category/index.js");

var Control_Plus = require("../Control.Plus/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Foldable = require("../Data.Foldable/index.js");

var Data_FoldableWithIndex = require("../Data.FoldableWithIndex/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_FunctorWithIndex = require("../Data.FunctorWithIndex/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Ordering = require("../Data.Ordering/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Semigroup_Foldable = require("../Data.Semigroup.Foldable/index.js");

var Data_Show = require("../Data.Show/index.js");

var Data_Traversable = require("../Data.Traversable/index.js");

var Data_TraversableWithIndex = require("../Data.TraversableWithIndex/index.js");

var Data_Tuple = require("../Data.Tuple/index.js");

var Data_Unfoldable = require("../Data.Unfoldable/index.js");

var Data_Unfoldable1 = require("../Data.Unfoldable1/index.js");

var NonEmpty = function () {
  function NonEmpty(value0, value1) {
    this.value0 = value0;
    this.value1 = value1;
  }

  ;

  NonEmpty.create = function (value0) {
    return function (value1) {
      return new NonEmpty(value0, value1);
    };
  };

  return NonEmpty;
}();

var unfoldable1NonEmpty = function unfoldable1NonEmpty(dictUnfoldable) {
  return new Data_Unfoldable1.Unfoldable1(function (f) {
    return function (b) {
      return Data_Tuple.uncurry(NonEmpty.create)(Data_Functor.map(Data_Tuple.functorTuple)(Data_Unfoldable.unfoldr(dictUnfoldable)(Data_Functor.map(Data_Maybe.functorMaybe)(f)))(f(b)));
    };
  });
};

var tail = function tail(v) {
  return v.value1;
};

var singleton = function singleton(dictPlus) {
  return function (a) {
    return new NonEmpty(a, Control_Plus.empty(dictPlus));
  };
};

var showNonEmpty = function showNonEmpty(dictShow) {
  return function (dictShow1) {
    return new Data_Show.Show(function (v) {
      return "(NonEmpty " + (Data_Show.show(dictShow)(v.value0) + (" " + (Data_Show.show(dictShow1)(v.value1) + ")")));
    });
  };
};

var oneOf = function oneOf(dictAlternative) {
  return function (v) {
    return Control_Alt.alt(dictAlternative.Plus1().Alt0())(Control_Applicative.pure(dictAlternative.Applicative0())(v.value0))(v.value1);
  };
};

var head = function head(v) {
  return v.value0;
};

var functorNonEmpty = function functorNonEmpty(dictFunctor) {
  return new Data_Functor.Functor(function (f) {
    return function (m) {
      return new NonEmpty(f(m.value0), Data_Functor.map(dictFunctor)(f)(m.value1));
    };
  });
};

var functorWithIndex = function functorWithIndex(dictFunctorWithIndex) {
  return new Data_FunctorWithIndex.FunctorWithIndex(function () {
    return functorNonEmpty(dictFunctorWithIndex.Functor0());
  }, function (f) {
    return function (v) {
      return new NonEmpty(f(Data_Maybe.Nothing.value)(v.value0), Data_FunctorWithIndex.mapWithIndex(dictFunctorWithIndex)(function ($146) {
        return f(Data_Maybe.Just.create($146));
      })(v.value1));
    };
  });
};

var fromNonEmpty = function fromNonEmpty(f) {
  return function (v) {
    return f(v.value0)(v.value1);
  };
};

var foldl1 = function foldl1(dictFoldable) {
  return function (f) {
    return function (v) {
      return Data_Foldable.foldl(dictFoldable)(f)(v.value0)(v.value1);
    };
  };
};

var foldableNonEmpty = function foldableNonEmpty(dictFoldable) {
  return new Data_Foldable.Foldable(function (dictMonoid) {
    return function (f) {
      return function (v) {
        return Data_Semigroup.append(dictMonoid.Semigroup0())(f(v.value0))(Data_Foldable.foldMap(dictFoldable)(dictMonoid)(f)(v.value1));
      };
    };
  }, function (f) {
    return function (b) {
      return function (v) {
        return Data_Foldable.foldl(dictFoldable)(f)(f(b)(v.value0))(v.value1);
      };
    };
  }, function (f) {
    return function (b) {
      return function (v) {
        return f(v.value0)(Data_Foldable.foldr(dictFoldable)(f)(b)(v.value1));
      };
    };
  });
};

var foldableWithIndexNonEmpty = function foldableWithIndexNonEmpty(dictFoldableWithIndex) {
  return new Data_FoldableWithIndex.FoldableWithIndex(function () {
    return foldableNonEmpty(dictFoldableWithIndex.Foldable0());
  }, function (dictMonoid) {
    return function (f) {
      return function (v) {
        return Data_Semigroup.append(dictMonoid.Semigroup0())(f(Data_Maybe.Nothing.value)(v.value0))(Data_FoldableWithIndex.foldMapWithIndex(dictFoldableWithIndex)(dictMonoid)(function ($147) {
          return f(Data_Maybe.Just.create($147));
        })(v.value1));
      };
    };
  }, function (f) {
    return function (b) {
      return function (v) {
        return Data_FoldableWithIndex.foldlWithIndex(dictFoldableWithIndex)(function ($148) {
          return f(Data_Maybe.Just.create($148));
        })(f(Data_Maybe.Nothing.value)(b)(v.value0))(v.value1);
      };
    };
  }, function (f) {
    return function (b) {
      return function (v) {
        return f(Data_Maybe.Nothing.value)(v.value0)(Data_FoldableWithIndex.foldrWithIndex(dictFoldableWithIndex)(function ($149) {
          return f(Data_Maybe.Just.create($149));
        })(b)(v.value1));
      };
    };
  });
};

var traversableNonEmpty = function traversableNonEmpty(dictTraversable) {
  return new Data_Traversable.Traversable(function () {
    return foldableNonEmpty(dictTraversable.Foldable1());
  }, function () {
    return functorNonEmpty(dictTraversable.Functor0());
  }, function (dictApplicative) {
    return function (v) {
      return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map(dictApplicative.Apply0().Functor0())(NonEmpty.create)(v.value0))(Data_Traversable.sequence(dictTraversable)(dictApplicative)(v.value1));
    };
  }, function (dictApplicative) {
    return function (f) {
      return function (v) {
        return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map(dictApplicative.Apply0().Functor0())(NonEmpty.create)(f(v.value0)))(Data_Traversable.traverse(dictTraversable)(dictApplicative)(f)(v.value1));
      };
    };
  });
};

var traversableWithIndexNonEmpty = function traversableWithIndexNonEmpty(dictTraversableWithIndex) {
  return new Data_TraversableWithIndex.TraversableWithIndex(function () {
    return foldableWithIndexNonEmpty(dictTraversableWithIndex.FoldableWithIndex1());
  }, function () {
    return functorWithIndex(dictTraversableWithIndex.FunctorWithIndex0());
  }, function () {
    return traversableNonEmpty(dictTraversableWithIndex.Traversable2());
  }, function (dictApplicative) {
    return function (f) {
      return function (v) {
        return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map(dictApplicative.Apply0().Functor0())(NonEmpty.create)(f(Data_Maybe.Nothing.value)(v.value0)))(Data_TraversableWithIndex.traverseWithIndex(dictTraversableWithIndex)(dictApplicative)(function ($150) {
          return f(Data_Maybe.Just.create($150));
        })(v.value1));
      };
    };
  });
};

var foldable1NonEmpty = function foldable1NonEmpty(dictFoldable) {
  return new Data_Semigroup_Foldable.Foldable1(function () {
    return foldableNonEmpty(dictFoldable);
  }, function (dictSemigroup) {
    return Data_Semigroup_Foldable.foldMap1(foldable1NonEmpty(dictFoldable))(dictSemigroup)(Control_Category.identity(Control_Category.categoryFn));
  }, function (dictSemigroup) {
    return function (f) {
      return function (v) {
        return Data_Foldable.foldl(dictFoldable)(function (s) {
          return function (a1) {
            return Data_Semigroup.append(dictSemigroup)(s)(f(a1));
          };
        })(f(v.value0))(v.value1);
      };
    };
  });
};

var eqNonEmpty = function eqNonEmpty(dictEq1) {
  return function (dictEq) {
    return new Data_Eq.Eq(function (x) {
      return function (y) {
        return Data_Eq.eq(dictEq)(x.value0)(y.value0) && Data_Eq.eq1(dictEq1)(dictEq)(x.value1)(y.value1);
      };
    });
  };
};

var ordNonEmpty = function ordNonEmpty(dictOrd1) {
  return function (dictOrd) {
    return new Data_Ord.Ord(function () {
      return eqNonEmpty(dictOrd1.Eq10())(dictOrd.Eq0());
    }, function (x) {
      return function (y) {
        var v = Data_Ord.compare(dictOrd)(x.value0)(y.value0);

        if (v instanceof Data_Ordering.LT) {
          return Data_Ordering.LT.value;
        }

        ;

        if (v instanceof Data_Ordering.GT) {
          return Data_Ordering.GT.value;
        }

        ;
        return Data_Ord.compare1(dictOrd1)(dictOrd)(x.value1)(y.value1);
      };
    });
  };
};

var eq1NonEmpty = function eq1NonEmpty(dictEq1) {
  return new Data_Eq.Eq1(function (dictEq) {
    return Data_Eq.eq(eqNonEmpty(dictEq1)(dictEq));
  });
};

var ord1NonEmpty = function ord1NonEmpty(dictOrd1) {
  return new Data_Ord.Ord1(function () {
    return eq1NonEmpty(dictOrd1.Eq10());
  }, function (dictOrd) {
    return Data_Ord.compare(ordNonEmpty(dictOrd1)(dictOrd));
  });
};

module.exports = {
  NonEmpty: NonEmpty,
  singleton: singleton,
  foldl1: foldl1,
  fromNonEmpty: fromNonEmpty,
  oneOf: oneOf,
  head: head,
  tail: tail,
  showNonEmpty: showNonEmpty,
  eqNonEmpty: eqNonEmpty,
  eq1NonEmpty: eq1NonEmpty,
  ordNonEmpty: ordNonEmpty,
  ord1NonEmpty: ord1NonEmpty,
  functorNonEmpty: functorNonEmpty,
  functorWithIndex: functorWithIndex,
  foldableNonEmpty: foldableNonEmpty,
  foldableWithIndexNonEmpty: foldableWithIndexNonEmpty,
  traversableNonEmpty: traversableNonEmpty,
  traversableWithIndexNonEmpty: traversableWithIndexNonEmpty,
  foldable1NonEmpty: foldable1NonEmpty,
  unfoldable1NonEmpty: unfoldable1NonEmpty
};
},{"../Control.Alt/index.js":"../output/Control.Alt/index.js","../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Control.Plus/index.js":"../output/Control.Plus/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Foldable/index.js":"../output/Data.Foldable/index.js","../Data.FoldableWithIndex/index.js":"../output/Data.FoldableWithIndex/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.FunctorWithIndex/index.js":"../output/Data.FunctorWithIndex/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Ordering/index.js":"../output/Data.Ordering/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Semigroup.Foldable/index.js":"../output/Data.Semigroup.Foldable/index.js","../Data.Show/index.js":"../output/Data.Show/index.js","../Data.Traversable/index.js":"../output/Data.Traversable/index.js","../Data.TraversableWithIndex/index.js":"../output/Data.TraversableWithIndex/index.js","../Data.Tuple/index.js":"../output/Data.Tuple/index.js","../Data.Unfoldable/index.js":"../output/Data.Unfoldable/index.js","../Data.Unfoldable1/index.js":"../output/Data.Unfoldable1/index.js"}],"../output/Data.List.Types/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Control_Alt = require("../Control.Alt/index.js");

var Control_Alternative = require("../Control.Alternative/index.js");

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Category = require("../Control.Category/index.js");

var Control_Comonad = require("../Control.Comonad/index.js");

var Control_Extend = require("../Control.Extend/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Control_MonadPlus = require("../Control.MonadPlus/index.js");

var Control_MonadZero = require("../Control.MonadZero/index.js");

var Control_Plus = require("../Control.Plus/index.js");

var Data_Eq = require("../Data.Eq/index.js");

var Data_Foldable = require("../Data.Foldable/index.js");

var Data_FoldableWithIndex = require("../Data.FoldableWithIndex/index.js");

var Data_Function = require("../Data.Function/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_FunctorWithIndex = require("../Data.FunctorWithIndex/index.js");

var Data_Maybe = require("../Data.Maybe/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Newtype = require("../Data.Newtype/index.js");

var Data_NonEmpty = require("../Data.NonEmpty/index.js");

var Data_Ord = require("../Data.Ord/index.js");

var Data_Ordering = require("../Data.Ordering/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var Data_Semigroup_Traversable = require("../Data.Semigroup.Traversable/index.js");

var Data_Semiring = require("../Data.Semiring/index.js");

var Data_Show = require("../Data.Show/index.js");

var Data_Traversable = require("../Data.Traversable/index.js");

var Data_TraversableWithIndex = require("../Data.TraversableWithIndex/index.js");

var Data_Tuple = require("../Data.Tuple/index.js");

var Data_Unfoldable = require("../Data.Unfoldable/index.js");

var Data_Unfoldable1 = require("../Data.Unfoldable1/index.js");

var Nil = function () {
  function Nil() {}

  ;
  Nil.value = new Nil();
  return Nil;
}();

var Cons = function () {
  function Cons(value0, value1) {
    this.value0 = value0;
    this.value1 = value1;
  }

  ;

  Cons.create = function (value0) {
    return function (value1) {
      return new Cons(value0, value1);
    };
  };

  return Cons;
}();

var NonEmptyList = function NonEmptyList(x) {
  return x;
};

var toList = function toList(v) {
  return new Cons(v.value0, v.value1);
};

var newtypeNonEmptyList = new Data_Newtype.Newtype(function (n) {
  return n;
}, NonEmptyList);

var nelCons = function nelCons(a) {
  return function (v) {
    return new Data_NonEmpty.NonEmpty(a, new Cons(v.value0, v.value1));
  };
};

var listMap = function listMap(f) {
  var chunkedRevMap = function chunkedRevMap($copy_chunksAcc) {
    return function ($copy_v) {
      var $tco_var_chunksAcc = $copy_chunksAcc;
      var $tco_done = false;
      var $tco_result;

      function $tco_loop(chunksAcc, v) {
        if (v instanceof Cons && v.value1 instanceof Cons && v.value1.value1 instanceof Cons) {
          $tco_var_chunksAcc = new Cons(v, chunksAcc);
          $copy_v = v.value1.value1.value1;
          return;
        }

        ;

        var unrolledMap = function unrolledMap(v1) {
          if (v1 instanceof Cons && v1.value1 instanceof Cons && v1.value1.value1 instanceof Nil) {
            return new Cons(f(v1.value0), new Cons(f(v1.value1.value0), Nil.value));
          }

          ;

          if (v1 instanceof Cons && v1.value1 instanceof Nil) {
            return new Cons(f(v1.value0), Nil.value);
          }

          ;
          return Nil.value;
        };

        var reverseUnrolledMap = function reverseUnrolledMap($copy_v1) {
          return function ($copy_acc) {
            var $tco_var_v1 = $copy_v1;
            var $tco_done = false;
            var $tco_result;

            function $tco_loop(v1, acc) {
              if (v1 instanceof Cons && v1.value0 instanceof Cons && v1.value0.value1 instanceof Cons && v1.value0.value1.value1 instanceof Cons) {
                $tco_var_v1 = v1.value1;
                $copy_acc = new Cons(f(v1.value0.value0), new Cons(f(v1.value0.value1.value0), new Cons(f(v1.value0.value1.value1.value0), acc)));
                return;
              }

              ;
              $tco_done = true;
              return acc;
            }

            ;

            while (!$tco_done) {
              $tco_result = $tco_loop($tco_var_v1, $copy_acc);
            }

            ;
            return $tco_result;
          };
        };

        $tco_done = true;
        return reverseUnrolledMap(chunksAcc)(unrolledMap(v));
      }

      ;

      while (!$tco_done) {
        $tco_result = $tco_loop($tco_var_chunksAcc, $copy_v);
      }

      ;
      return $tco_result;
    };
  };

  return chunkedRevMap(Nil.value);
};

var functorList = new Data_Functor.Functor(listMap);
var functorNonEmptyList = Data_NonEmpty.functorNonEmpty(functorList);
var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {
  return function (f) {
    return Data_Foldable.foldl(foldableList)(function (acc) {
      var $202 = Data_Semigroup.append(dictMonoid.Semigroup0())(acc);
      return function ($203) {
        return $202(f($203));
      };
    })(Data_Monoid.mempty(dictMonoid));
  };
}, function (f) {
  var go = function go($copy_b) {
    return function ($copy_v) {
      var $tco_var_b = $copy_b;
      var $tco_done = false;
      var $tco_result;

      function $tco_loop(b, v) {
        if (v instanceof Nil) {
          $tco_done = true;
          return b;
        }

        ;

        if (v instanceof Cons) {
          $tco_var_b = f(b)(v.value0);
          $copy_v = v.value1;
          return;
        }

        ;
        throw new Error("Failed pattern match at Data.List.Types (line 109, column 12 - line 111, column 30): " + [v.constructor.name]);
      }

      ;

      while (!$tco_done) {
        $tco_result = $tco_loop($tco_var_b, $copy_v);
      }

      ;
      return $tco_result;
    };
  };

  return go;
}, function (f) {
  return function (b) {
    var rev = Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value);
    var $204 = Data_Foldable.foldl(foldableList)(Data_Function.flip(f))(b);
    return function ($205) {
      return $204(rev($205));
    };
  };
});
var foldableNonEmptyList = Data_NonEmpty.foldableNonEmpty(foldableList);
var foldableWithIndexList = new Data_FoldableWithIndex.FoldableWithIndex(function () {
  return foldableList;
}, function (dictMonoid) {
  return function (f) {
    return Data_FoldableWithIndex.foldlWithIndex(foldableWithIndexList)(function (i) {
      return function (acc) {
        var $206 = Data_Semigroup.append(dictMonoid.Semigroup0())(acc);
        var $207 = f(i);
        return function ($208) {
          return $206($207($208));
        };
      };
    })(Data_Monoid.mempty(dictMonoid));
  };
}, function (f) {
  return function (acc) {
    var $209 = Data_Foldable.foldl(foldableList)(function (v) {
      return function (a) {
        return new Data_Tuple.Tuple(v.value0 + 1 | 0, f(v.value0)(v.value1)(a));
      };
    })(new Data_Tuple.Tuple(0, acc));
    return function ($210) {
      return Data_Tuple.snd($209($210));
    };
  };
}, function (f) {
  return function (b) {
    return function (xs) {
      var v = function () {
        var rev = Data_Foldable.foldl(foldableList)(function (v1) {
          return function (a) {
            return new Data_Tuple.Tuple(v1.value0 + 1 | 0, new Cons(a, v1.value1));
          };
        });
        return rev(new Data_Tuple.Tuple(0, Nil.value))(xs);
      }();

      return Data_Tuple.snd(Data_Foldable.foldl(foldableList)(function (v1) {
        return function (a) {
          return new Data_Tuple.Tuple(v1.value0 - 1 | 0, f(v1.value0 - 1 | 0)(a)(v1.value1));
        };
      })(new Data_Tuple.Tuple(v.value0, b))(v.value1));
    };
  };
});
var foldableWithIndexNonEmptyList = new Data_FoldableWithIndex.FoldableWithIndex(function () {
  return foldableNonEmptyList;
}, function (dictMonoid) {
  return function (f) {
    return function (v) {
      return Data_FoldableWithIndex.foldMapWithIndex(Data_NonEmpty.foldableWithIndexNonEmpty(foldableWithIndexList))(dictMonoid)(function () {
        var $211 = Data_Maybe.maybe(0)(Data_Semiring.add(Data_Semiring.semiringInt)(1));
        return function ($212) {
          return f($211($212));
        };
      }())(v);
    };
  };
}, function (f) {
  return function (b) {
    return function (v) {
      return Data_FoldableWithIndex.foldlWithIndex(Data_NonEmpty.foldableWithIndexNonEmpty(foldableWithIndexList))(function () {
        var $213 = Data_Maybe.maybe(0)(Data_Semiring.add(Data_Semiring.semiringInt)(1));
        return function ($214) {
          return f($213($214));
        };
      }())(b)(v);
    };
  };
}, function (f) {
  return function (b) {
    return function (v) {
      return Data_FoldableWithIndex.foldrWithIndex(Data_NonEmpty.foldableWithIndexNonEmpty(foldableWithIndexList))(function () {
        var $215 = Data_Maybe.maybe(0)(Data_Semiring.add(Data_Semiring.semiringInt)(1));
        return function ($216) {
          return f($215($216));
        };
      }())(b)(v);
    };
  };
});
var functorWithIndexList = new Data_FunctorWithIndex.FunctorWithIndex(function () {
  return functorList;
}, function (f) {
  return Data_FoldableWithIndex.foldrWithIndex(foldableWithIndexList)(function (i) {
    return function (x) {
      return function (acc) {
        return new Cons(f(i)(x), acc);
      };
    };
  })(Nil.value);
});
var functorWithIndexNonEmptyList = new Data_FunctorWithIndex.FunctorWithIndex(function () {
  return functorNonEmptyList;
}, function (fn) {
  return function (v) {
    return NonEmptyList(Data_FunctorWithIndex.mapWithIndex(Data_NonEmpty.functorWithIndex(functorWithIndexList))(function () {
      var $217 = Data_Maybe.maybe(0)(Data_Semiring.add(Data_Semiring.semiringInt)(1));
      return function ($218) {
        return fn($217($218));
      };
    }())(v));
  };
});
var semigroupList = new Data_Semigroup.Semigroup(function (xs) {
  return function (ys) {
    return Data_Foldable.foldr(foldableList)(Cons.create)(ys)(xs);
  };
});
var monoidList = new Data_Monoid.Monoid(function () {
  return semigroupList;
}, Nil.value);
var semigroupNonEmptyList = new Data_Semigroup.Semigroup(function (v) {
  return function (as$prime) {
    return new Data_NonEmpty.NonEmpty(v.value0, Data_Semigroup.append(semigroupList)(v.value1)(toList(as$prime)));
  };
});

var showList = function showList(dictShow) {
  return new Data_Show.Show(function (v) {
    if (v instanceof Nil) {
      return "Nil";
    }

    ;
    return "(" + (Data_Foldable.intercalate(foldableList)(Data_Monoid.monoidString)(" : ")(Data_Functor.map(functorList)(Data_Show.show(dictShow))(v)) + " : Nil)");
  });
};

var showNonEmptyList = function showNonEmptyList(dictShow) {
  return new Data_Show.Show(function (v) {
    return "(NonEmptyList " + (Data_Show.show(Data_NonEmpty.showNonEmpty(dictShow)(showList(dictShow)))(v) + ")");
  });
};

var traversableList = new Data_Traversable.Traversable(function () {
  return foldableList;
}, function () {
  return functorList;
}, function (dictApplicative) {
  return Data_Traversable.traverse(traversableList)(dictApplicative)(Control_Category.identity(Control_Category.categoryFn));
}, function (dictApplicative) {
  return function (f) {
    var $219 = Data_Functor.map(dictApplicative.Apply0().Functor0())(Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value));
    var $220 = Data_Foldable.foldl(foldableList)(function (acc) {
      var $222 = Control_Apply.lift2(dictApplicative.Apply0())(Data_Function.flip(Cons.create))(acc);
      return function ($223) {
        return $222(f($223));
      };
    })(Control_Applicative.pure(dictApplicative)(Nil.value));
    return function ($221) {
      return $219($220($221));
    };
  };
});
var traversableNonEmptyList = Data_NonEmpty.traversableNonEmpty(traversableList);
var traversableWithIndexList = new Data_TraversableWithIndex.TraversableWithIndex(function () {
  return foldableWithIndexList;
}, function () {
  return functorWithIndexList;
}, function () {
  return traversableList;
}, function (dictApplicative) {
  return function (f) {
    var rev = Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value);
    var $224 = Data_Functor.map(dictApplicative.Apply0().Functor0())(rev);
    var $225 = Data_FoldableWithIndex.foldlWithIndex(foldableWithIndexList)(function (i) {
      return function (acc) {
        var $227 = Control_Apply.lift2(dictApplicative.Apply0())(Data_Function.flip(Cons.create))(acc);
        var $228 = f(i);
        return function ($229) {
          return $227($228($229));
        };
      };
    })(Control_Applicative.pure(dictApplicative)(Nil.value));
    return function ($226) {
      return $224($225($226));
    };
  };
});
var traversableWithIndexNonEmptyList = new Data_TraversableWithIndex.TraversableWithIndex(function () {
  return foldableWithIndexNonEmptyList;
}, function () {
  return functorWithIndexNonEmptyList;
}, function () {
  return traversableNonEmptyList;
}, function (dictApplicative) {
  return function (f) {
    return function (v) {
      return Data_Functor.map(dictApplicative.Apply0().Functor0())(NonEmptyList)(Data_TraversableWithIndex.traverseWithIndex(Data_NonEmpty.traversableWithIndexNonEmpty(traversableWithIndexList))(dictApplicative)(function () {
        var $230 = Data_Maybe.maybe(0)(Data_Semiring.add(Data_Semiring.semiringInt)(1));
        return function ($231) {
          return f($230($231));
        };
      }())(v));
    };
  };
});
var unfoldable1List = new Data_Unfoldable1.Unfoldable1(function (f) {
  return function (b) {
    var go = function go($copy_source) {
      return function ($copy_memo) {
        var $tco_var_source = $copy_source;
        var $tco_done = false;
        var $tco_result;

        function $tco_loop(source, memo) {
          var v = f(source);

          if (v.value1 instanceof Data_Maybe.Just) {
            $tco_var_source = v.value1.value0;
            $copy_memo = new Cons(v.value0, memo);
            return;
          }

          ;

          if (v.value1 instanceof Data_Maybe.Nothing) {
            $tco_done = true;
            return Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value)(new Cons(v.value0, memo));
          }

          ;
          throw new Error("Failed pattern match at Data.List.Types (line 133, column 22 - line 135, column 61): " + [v.constructor.name]);
        }

        ;

        while (!$tco_done) {
          $tco_result = $tco_loop($tco_var_source, $copy_memo);
        }

        ;
        return $tco_result;
      };
    };

    return go(b)(Nil.value);
  };
});
var unfoldableList = new Data_Unfoldable.Unfoldable(function () {
  return unfoldable1List;
}, function (f) {
  return function (b) {
    var go = function go($copy_source) {
      return function ($copy_memo) {
        var $tco_var_source = $copy_source;
        var $tco_done = false;
        var $tco_result;

        function $tco_loop(source, memo) {
          var v = f(source);

          if (v instanceof Data_Maybe.Nothing) {
            $tco_done = true;
            return Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value)(memo);
          }

          ;

          if (v instanceof Data_Maybe.Just) {
            $tco_var_source = v.value0.value1;
            $copy_memo = new Cons(v.value0.value0, memo);
            return;
          }

          ;
          throw new Error("Failed pattern match at Data.List.Types (line 140, column 22 - line 142, column 52): " + [v.constructor.name]);
        }

        ;

        while (!$tco_done) {
          $tco_result = $tco_loop($tco_var_source, $copy_memo);
        }

        ;
        return $tco_result;
      };
    };

    return go(b)(Nil.value);
  };
});
var unfoldable1NonEmptyList = Data_NonEmpty.unfoldable1NonEmpty(unfoldableList);
var foldable1NonEmptyList = Data_NonEmpty.foldable1NonEmpty(foldableList);
var extendNonEmptyList = new Control_Extend.Extend(function () {
  return functorNonEmptyList;
}, function (f) {
  return function (v) {
    var go = function go(a) {
      return function (v1) {
        return {
          val: new Cons(f(new Data_NonEmpty.NonEmpty(a, v1.acc)), v1.val),
          acc: new Cons(a, v1.acc)
        };
      };
    };

    return new Data_NonEmpty.NonEmpty(f(v), Data_Foldable.foldr(foldableList)(go)({
      val: Nil.value,
      acc: Nil.value
    })(v.value1).val);
  };
});
var extendList = new Control_Extend.Extend(function () {
  return functorList;
}, function (f) {
  return function (v) {
    if (v instanceof Nil) {
      return Nil.value;
    }

    ;

    if (v instanceof Cons) {
      var go = function go(a$prime) {
        return function (v1) {
          var acc$prime = new Cons(a$prime, v1.acc);
          return {
            val: new Cons(f(acc$prime), v1.val),
            acc: acc$prime
          };
        };
      };

      return new Cons(f(v), Data_Foldable.foldr(foldableList)(go)({
        val: Nil.value,
        acc: Nil.value
      })(v.value1).val);
    }

    ;
    throw new Error("Failed pattern match at Data.List.Types (line 180, column 1 - line 187, column 42): " + [f.constructor.name, v.constructor.name]);
  };
});
var eq1List = new Data_Eq.Eq1(function (dictEq) {
  return function (xs) {
    return function (ys) {
      var go = function go($copy_v) {
        return function ($copy_v1) {
          return function ($copy_v2) {
            var $tco_var_v = $copy_v;
            var $tco_var_v1 = $copy_v1;
            var $tco_done = false;
            var $tco_result;

            function $tco_loop(v, v1, v2) {
              if (!v2) {
                $tco_done = true;
                return false;
              }

              ;

              if (v instanceof Nil && v1 instanceof Nil) {
                $tco_done = true;
                return v2;
              }

              ;

              if (v instanceof Cons && v1 instanceof Cons) {
                $tco_var_v = v.value1;
                $tco_var_v1 = v1.value1;
                $copy_v2 = v2 && Data_Eq.eq(dictEq)(v1.value0)(v.value0);
                return;
              }

              ;
              $tco_done = true;
              return false;
            }

            ;

            while (!$tco_done) {
              $tco_result = $tco_loop($tco_var_v, $tco_var_v1, $copy_v2);
            }

            ;
            return $tco_result;
          };
        };
      };

      return go(xs)(ys)(true);
    };
  };
});

var eqList = function eqList(dictEq) {
  return new Data_Eq.Eq(Data_Eq.eq1(eq1List)(dictEq));
};

var eqNonEmptyList = function eqNonEmptyList(dictEq) {
  return Data_NonEmpty.eqNonEmpty(eq1List)(dictEq);
};

var ord1List = new Data_Ord.Ord1(function () {
  return eq1List;
}, function (dictOrd) {
  return function (xs) {
    return function (ys) {
      var go = function go($copy_v) {
        return function ($copy_v1) {
          var $tco_var_v = $copy_v;
          var $tco_done = false;
          var $tco_result;

          function $tco_loop(v, v1) {
            if (v instanceof Nil && v1 instanceof Nil) {
              $tco_done = true;
              return Data_Ordering.EQ.value;
            }

            ;

            if (v instanceof Nil) {
              $tco_done = true;
              return Data_Ordering.LT.value;
            }

            ;

            if (v1 instanceof Nil) {
              $tco_done = true;
              return Data_Ordering.GT.value;
            }

            ;

            if (v instanceof Cons && v1 instanceof Cons) {
              var v2 = Data_Ord.compare(dictOrd)(v.value0)(v1.value0);

              if (v2 instanceof Data_Ordering.EQ) {
                $tco_var_v = v.value1;
                $copy_v1 = v1.value1;
                return;
              }

              ;
              $tco_done = true;
              return v2;
            }

            ;
            throw new Error("Failed pattern match at Data.List.Types (line 61, column 5 - line 61, column 20): " + [v.constructor.name, v1.constructor.name]);
          }

          ;

          while (!$tco_done) {
            $tco_result = $tco_loop($tco_var_v, $copy_v1);
          }

          ;
          return $tco_result;
        };
      };

      return go(xs)(ys);
    };
  };
});

var ordList = function ordList(dictOrd) {
  return new Data_Ord.Ord(function () {
    return eqList(dictOrd.Eq0());
  }, Data_Ord.compare1(ord1List)(dictOrd));
};

var ordNonEmptyList = function ordNonEmptyList(dictOrd) {
  return Data_NonEmpty.ordNonEmpty(ord1List)(dictOrd);
};

var comonadNonEmptyList = new Control_Comonad.Comonad(function () {
  return extendNonEmptyList;
}, function (v) {
  return v.value0;
});
var applyList = new Control_Apply.Apply(function () {
  return functorList;
}, function (v) {
  return function (v1) {
    if (v instanceof Nil) {
      return Nil.value;
    }

    ;

    if (v instanceof Cons) {
      return Data_Semigroup.append(semigroupList)(Data_Functor.map(functorList)(v.value0)(v1))(Control_Apply.apply(applyList)(v.value1)(v1));
    }

    ;
    throw new Error("Failed pattern match at Data.List.Types (line 155, column 1 - line 157, column 48): " + [v.constructor.name, v1.constructor.name]);
  };
});
var applyNonEmptyList = new Control_Apply.Apply(function () {
  return functorNonEmptyList;
}, function (v) {
  return function (v1) {
    return new Data_NonEmpty.NonEmpty(v.value0(v1.value0), Data_Semigroup.append(semigroupList)(Control_Apply.apply(applyList)(v.value1)(new Cons(v1.value0, Nil.value)))(Control_Apply.apply(applyList)(new Cons(v.value0, v.value1))(v1.value1)));
  };
});
var bindList = new Control_Bind.Bind(function () {
  return applyList;
}, function (v) {
  return function (v1) {
    if (v instanceof Nil) {
      return Nil.value;
    }

    ;

    if (v instanceof Cons) {
      return Data_Semigroup.append(semigroupList)(v1(v.value0))(Control_Bind.bind(bindList)(v.value1)(v1));
    }

    ;
    throw new Error("Failed pattern match at Data.List.Types (line 162, column 1 - line 164, column 37): " + [v.constructor.name, v1.constructor.name]);
  };
});
var bindNonEmptyList = new Control_Bind.Bind(function () {
  return applyNonEmptyList;
}, function (v) {
  return function (f) {
    var v1 = f(v.value0);
    return new Data_NonEmpty.NonEmpty(v1.value0, Data_Semigroup.append(semigroupList)(v1.value1)(Control_Bind.bind(bindList)(v.value1)(function ($232) {
      return toList(f($232));
    })));
  };
});
var applicativeList = new Control_Applicative.Applicative(function () {
  return applyList;
}, function (a) {
  return new Cons(a, Nil.value);
});
var monadList = new Control_Monad.Monad(function () {
  return applicativeList;
}, function () {
  return bindList;
});
var altNonEmptyList = new Control_Alt.Alt(function () {
  return functorNonEmptyList;
}, Data_Semigroup.append(semigroupNonEmptyList));
var altList = new Control_Alt.Alt(function () {
  return functorList;
}, Data_Semigroup.append(semigroupList));
var plusList = new Control_Plus.Plus(function () {
  return altList;
}, Nil.value);
var alternativeList = new Control_Alternative.Alternative(function () {
  return applicativeList;
}, function () {
  return plusList;
});
var monadZeroList = new Control_MonadZero.MonadZero(function () {
  return alternativeList;
}, function () {
  return monadList;
});
var monadPlusList = new Control_MonadPlus.MonadPlus(function () {
  return monadZeroList;
});
var applicativeNonEmptyList = new Control_Applicative.Applicative(function () {
  return applyNonEmptyList;
}, function () {
  var $233 = Data_NonEmpty.singleton(plusList);
  return function ($234) {
    return NonEmptyList($233($234));
  };
}());
var monadNonEmptyList = new Control_Monad.Monad(function () {
  return applicativeNonEmptyList;
}, function () {
  return bindNonEmptyList;
});
var traversable1NonEmptyList = new Data_Semigroup_Traversable.Traversable1(function () {
  return foldable1NonEmptyList;
}, function () {
  return traversableNonEmptyList;
}, function (dictApply) {
  return Data_Semigroup_Traversable.traverse1(traversable1NonEmptyList)(dictApply)(Control_Category.identity(Control_Category.categoryFn));
}, function (dictApply) {
  return function (f) {
    return function (v) {
      return Data_Functor.mapFlipped(dictApply.Functor0())(Data_Foldable.foldl(foldableList)(function (acc) {
        var $235 = Control_Apply.lift2(dictApply)(Data_Function.flip(nelCons))(acc);
        return function ($236) {
          return $235(f($236));
        };
      })(Data_Functor.map(dictApply.Functor0())(Control_Applicative.pure(applicativeNonEmptyList))(f(v.value0)))(v.value1))(function (v1) {
        return Data_Foldable.foldl(foldableList)(Data_Function.flip(nelCons))(Control_Applicative.pure(applicativeNonEmptyList)(v1.value0))(v1.value1);
      });
    };
  };
});
module.exports = {
  Nil: Nil,
  Cons: Cons,
  NonEmptyList: NonEmptyList,
  toList: toList,
  nelCons: nelCons,
  showList: showList,
  eqList: eqList,
  eq1List: eq1List,
  ordList: ordList,
  ord1List: ord1List,
  semigroupList: semigroupList,
  monoidList: monoidList,
  functorList: functorList,
  functorWithIndexList: functorWithIndexList,
  foldableList: foldableList,
  foldableWithIndexList: foldableWithIndexList,
  unfoldable1List: unfoldable1List,
  unfoldableList: unfoldableList,
  traversableList: traversableList,
  traversableWithIndexList: traversableWithIndexList,
  applyList: applyList,
  applicativeList: applicativeList,
  bindList: bindList,
  monadList: monadList,
  altList: altList,
  plusList: plusList,
  alternativeList: alternativeList,
  monadZeroList: monadZeroList,
  monadPlusList: monadPlusList,
  extendList: extendList,
  newtypeNonEmptyList: newtypeNonEmptyList,
  eqNonEmptyList: eqNonEmptyList,
  ordNonEmptyList: ordNonEmptyList,
  showNonEmptyList: showNonEmptyList,
  functorNonEmptyList: functorNonEmptyList,
  applyNonEmptyList: applyNonEmptyList,
  applicativeNonEmptyList: applicativeNonEmptyList,
  bindNonEmptyList: bindNonEmptyList,
  monadNonEmptyList: monadNonEmptyList,
  altNonEmptyList: altNonEmptyList,
  extendNonEmptyList: extendNonEmptyList,
  comonadNonEmptyList: comonadNonEmptyList,
  semigroupNonEmptyList: semigroupNonEmptyList,
  foldableNonEmptyList: foldableNonEmptyList,
  traversableNonEmptyList: traversableNonEmptyList,
  foldable1NonEmptyList: foldable1NonEmptyList,
  unfoldable1NonEmptyList: unfoldable1NonEmptyList,
  functorWithIndexNonEmptyList: functorWithIndexNonEmptyList,
  foldableWithIndexNonEmptyList: foldableWithIndexNonEmptyList,
  traversableWithIndexNonEmptyList: traversableWithIndexNonEmptyList,
  traversable1NonEmptyList: traversable1NonEmptyList
};
},{"../Control.Alt/index.js":"../output/Control.Alt/index.js","../Control.Alternative/index.js":"../output/Control.Alternative/index.js","../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Category/index.js":"../output/Control.Category/index.js","../Control.Comonad/index.js":"../output/Control.Comonad/index.js","../Control.Extend/index.js":"../output/Control.Extend/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Control.MonadPlus/index.js":"../output/Control.MonadPlus/index.js","../Control.MonadZero/index.js":"../output/Control.MonadZero/index.js","../Control.Plus/index.js":"../output/Control.Plus/index.js","../Data.Eq/index.js":"../output/Data.Eq/index.js","../Data.Foldable/index.js":"../output/Data.Foldable/index.js","../Data.FoldableWithIndex/index.js":"../output/Data.FoldableWithIndex/index.js","../Data.Function/index.js":"../output/Data.Function/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.FunctorWithIndex/index.js":"../output/Data.FunctorWithIndex/index.js","../Data.Maybe/index.js":"../output/Data.Maybe/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Newtype/index.js":"../output/Data.Newtype/index.js","../Data.NonEmpty/index.js":"../output/Data.NonEmpty/index.js","../Data.Ord/index.js":"../output/Data.Ord/index.js","../Data.Ordering/index.js":"../output/Data.Ordering/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js","../Data.Semigroup.Traversable/index.js":"../output/Data.Semigroup.Traversable/index.js","../Data.Semiring/index.js":"../output/Data.Semiring/index.js","../Data.Show/index.js":"../output/Data.Show/index.js","../Data.Traversable/index.js":"../output/Data.Traversable/index.js","../Data.TraversableWithIndex/index.js":"../output/Data.TraversableWithIndex/index.js","../Data.Tuple/index.js":"../output/Data.Tuple/index.js","../Data.Unfoldable/index.js":"../output/Data.Unfoldable/index.js","../Data.Unfoldable1/index.js":"../output/Data.Unfoldable1/index.js"}],"../output/Data.Number.Format/foreign.js":[function(require,module,exports) {
function wrap(method) {
  return function (d) {
    return function (num) {
      return method.apply(num, [d]);
    };
  };
}

exports.toPrecisionNative = wrap(Number.prototype.toPrecision);
exports.toFixedNative = wrap(Number.prototype.toFixed);
exports.toExponentialNative = wrap(Number.prototype.toExponential);

exports.toString = function (num) {
  return num.toString();
};
},{}],"../output/Data.Number.Format/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Ord = require("../Data.Ord/index.js");

var Precision = function () {
  function Precision(value0) {
    this.value0 = value0;
  }

  ;

  Precision.create = function (value0) {
    return new Precision(value0);
  };

  return Precision;
}();

var Fixed = function () {
  function Fixed(value0) {
    this.value0 = value0;
  }

  ;

  Fixed.create = function (value0) {
    return new Fixed(value0);
  };

  return Fixed;
}();

var Exponential = function () {
  function Exponential(value0) {
    this.value0 = value0;
  }

  ;

  Exponential.create = function (value0) {
    return new Exponential(value0);
  };

  return Exponential;
}();

var toStringWith = function toStringWith(v) {
  if (v instanceof Precision) {
    return $foreign.toPrecisionNative(v.value0);
  }

  ;

  if (v instanceof Fixed) {
    return $foreign.toFixedNative(v.value0);
  }

  ;

  if (v instanceof Exponential) {
    return $foreign.toExponentialNative(v.value0);
  }

  ;
  throw new Error("Failed pattern match at Data.Number.Format (line 59, column 1 - line 59, column 40): " + [v.constructor.name]);
};

var precision = function () {
  var $5 = Data_Ord.clamp(Data_Ord.ordInt)(1)(21);
  return function ($6) {
    return Precision.create($5($6));
  };
}();

var fixed = function () {
  var $7 = Data_Ord.clamp(Data_Ord.ordInt)(0)(20);
  return function ($8) {
    return Fixed.create($7($8));
  };
}();

var exponential = function () {
  var $9 = Data_Ord.clamp(Data_Ord.ordInt)(0)(20);
  return function ($10) {
    return Exponential.create($9($10));
  };
}();

module.exports = {
  precision: precision,
  fixed: fixed,
  exponential: exponential,
  toStringWith: toStringWith,
  toString: $foreign.toString
};
},{"./foreign.js":"../output/Data.Number.Format/foreign.js","../Data.Ord/index.js":"../output/Data.Ord/index.js"}],"../output/Effect/foreign.js":[function(require,module,exports) {
"use strict";

exports.pureE = function (a) {
  return function () {
    return a;
  };
};

exports.bindE = function (a) {
  return function (f) {
    return function () {
      return f(a())();
    };
  };
};

exports.untilE = function (f) {
  return function () {
    while (!f()) {
      ;
    }

    return {};
  };
};

exports.whileE = function (f) {
  return function (a) {
    return function () {
      while (f()) {
        a();
      }

      return {};
    };
  };
};

exports.forE = function (lo) {
  return function (hi) {
    return function (f) {
      return function () {
        for (var i = lo; i < hi; i++) {
          f(i)();
        }
      };
    };
  };
};

exports.foreachE = function (as) {
  return function (f) {
    return function () {
      for (var i = 0, l = as.length; i < l; i++) {
        f(as[i])();
      }
    };
  };
};
},{}],"../output/Effect/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Control_Applicative = require("../Control.Applicative/index.js");

var Control_Apply = require("../Control.Apply/index.js");

var Control_Bind = require("../Control.Bind/index.js");

var Control_Monad = require("../Control.Monad/index.js");

var Data_Functor = require("../Data.Functor/index.js");

var Data_Monoid = require("../Data.Monoid/index.js");

var Data_Semigroup = require("../Data.Semigroup/index.js");

var monadEffect = new Control_Monad.Monad(function () {
  return applicativeEffect;
}, function () {
  return bindEffect;
});
var bindEffect = new Control_Bind.Bind(function () {
  return applyEffect;
}, $foreign.bindE);
var applyEffect = new Control_Apply.Apply(function () {
  return functorEffect;
}, Control_Monad.ap(monadEffect));
var applicativeEffect = new Control_Applicative.Applicative(function () {
  return applyEffect;
}, $foreign.pureE);
var functorEffect = new Data_Functor.Functor(Control_Applicative.liftA1(applicativeEffect));

var semigroupEffect = function semigroupEffect(dictSemigroup) {
  return new Data_Semigroup.Semigroup(Control_Apply.lift2(applyEffect)(Data_Semigroup.append(dictSemigroup)));
};

var monoidEffect = function monoidEffect(dictMonoid) {
  return new Data_Monoid.Monoid(function () {
    return semigroupEffect(dictMonoid.Semigroup0());
  }, $foreign.pureE(Data_Monoid.mempty(dictMonoid)));
};

module.exports = {
  functorEffect: functorEffect,
  applyEffect: applyEffect,
  applicativeEffect: applicativeEffect,
  bindEffect: bindEffect,
  monadEffect: monadEffect,
  semigroupEffect: semigroupEffect,
  monoidEffect: monoidEffect,
  untilE: $foreign.untilE,
  whileE: $foreign.whileE,
  forE: $foreign.forE,
  foreachE: $foreign.foreachE
};
},{"./foreign.js":"../output/Effect/foreign.js","../Control.Applicative/index.js":"../output/Control.Applicative/index.js","../Control.Apply/index.js":"../output/Control.Apply/index.js","../Control.Bind/index.js":"../output/Control.Bind/index.js","../Control.Monad/index.js":"../output/Control.Monad/index.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Data.Monoid/index.js":"../output/Data.Monoid/index.js","../Data.Semigroup/index.js":"../output/Data.Semigroup/index.js"}],"../output/Effect.Console/foreign.js":[function(require,module,exports) {
"use strict";

exports.log = function (s) {
  return function () {
    console.log(s);
    return {};
  };
};

exports.warn = function (s) {
  return function () {
    console.warn(s);
    return {};
  };
};

exports.error = function (s) {
  return function () {
    console.error(s);
    return {};
  };
};

exports.info = function (s) {
  return function () {
    console.info(s);
    return {};
  };
};

exports.time = function (s) {
  return function () {
    console.time(s);
    return {};
  };
};

exports.timeLog = function (s) {
  return function () {
    console.timeLog(s);
    return {};
  };
};

exports.timeEnd = function (s) {
  return function () {
    console.timeEnd(s);
    return {};
  };
};

exports.clear = function () {
  console.clear();
  return {};
};
},{}],"../output/Effect.Console/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Show = require("../Data.Show/index.js");

var warnShow = function warnShow(dictShow) {
  return function (a) {
    return $foreign.warn(Data_Show.show(dictShow)(a));
  };
};

var logShow = function logShow(dictShow) {
  return function (a) {
    return $foreign.log(Data_Show.show(dictShow)(a));
  };
};

var infoShow = function infoShow(dictShow) {
  return function (a) {
    return $foreign.info(Data_Show.show(dictShow)(a));
  };
};

var errorShow = function errorShow(dictShow) {
  return function (a) {
    return $foreign.error(Data_Show.show(dictShow)(a));
  };
};

module.exports = {
  logShow: logShow,
  warnShow: warnShow,
  errorShow: errorShow,
  infoShow: infoShow,
  log: $foreign.log,
  warn: $foreign.warn,
  error: $foreign.error,
  info: $foreign.info,
  time: $foreign.time,
  timeLog: $foreign.timeLog,
  timeEnd: $foreign.timeEnd,
  clear: $foreign.clear
};
},{"./foreign.js":"../output/Effect.Console/foreign.js","../Data.Show/index.js":"../output/Data.Show/index.js"}],"../output/Effect.Ref/foreign.js":[function(require,module,exports) {
"use strict";

exports.new = function (val) {
  return function () {
    return {
      value: val
    };
  };
};

exports.read = function (ref) {
  return function () {
    return ref.value;
  };
};

exports["modify'"] = function (f) {
  return function (ref) {
    return function () {
      var t = f(ref.value);
      ref.value = t.state;
      return t.value;
    };
  };
};

exports.write = function (val) {
  return function (ref) {
    return function () {
      ref.value = val;
      return {};
    };
  };
};
},{}],"../output/Effect.Ref/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var $foreign = require("./foreign.js");

var Data_Functor = require("../Data.Functor/index.js");

var Effect = require("../Effect/index.js");

var modify = function modify(f) {
  return $foreign["modify'"](function (s) {
    var s$prime = f(s);
    return {
      state: s$prime,
      value: s$prime
    };
  });
};

var modify_ = function modify_(f) {
  return function (s) {
    return Data_Functor["void"](Effect.functorEffect)(modify(f)(s));
  };
};

module.exports = {
  modify: modify,
  modify_: modify_,
  "new": $foreign["new"],
  read: $foreign.read,
  "modify'": $foreign["modify'"],
  write: $foreign.write
};
},{"./foreign.js":"../output/Effect.Ref/foreign.js","../Data.Functor/index.js":"../output/Data.Functor/index.js","../Effect/index.js":"../output/Effect/index.js"}],"../output/PureTabs.Background/index.js":[function(require,module,exports) {
// Generated by purs version 0.13.6
"use strict";

var Browser_Runtime = require("../Browser.Runtime/index.js");

var Browser_Tabs_OnCreated = require("../Browser.Tabs.OnCreated/index.js");

var Data_Foldable = require("../Data.Foldable/index.js");

var Data_List_Types = require("../Data.List.Types/index.js");

var Data_Number_Format = require("../Data.Number.Format/index.js");

var Effect = require("../Effect/index.js");

var Effect_Console = require("../Effect.Console/index.js");

var Effect_Ref = require("../Effect.Ref/index.js");

var main = function () {
  var sendCreatedTab = function sendCreatedTab(portsRef) {
    return function (tab) {
      var tabId = Data_Number_Format.toString(tab.id);
      return function __do() {
        Effect_Console.log("(bg) tab created" + tabId)();
        var ports = Effect_Ref.read(portsRef)();
        return Data_Foldable.for_(Effect.applicativeEffect)(Data_List_Types.foldableList)(ports)(function (p) {
          return Browser_Runtime.postMessage(p)(tabId);
        })();
      };
    };
  };

  var onConnect = function onConnect(ref) {
    return function (port) {
      return function __do() {
        Effect_Console.log("new connect")();
        return Effect_Ref.modify_(function (ports) {
          return new Data_List_Types.Cons(port, ports);
        })(ref)();
      };
    };
  };

  var logTabId = function logTabId(tab) {
    return Effect_Console.log(Data_Number_Format.toString(tab.id));
  };

  return function __do() {
    Effect_Console.log("started background")();
    var ports = Effect_Ref["new"](Data_List_Types.Nil.value)();
    Browser_Runtime.onConnectAddListener(onConnect(ports))();
    var listener = Browser_Tabs_OnCreated.mkListener(sendCreatedTab(ports))();
    return Browser_Tabs_OnCreated.addListener(listener)();
  };
}();

module.exports = {
  main: main
};
},{"../Browser.Runtime/index.js":"../output/Browser.Runtime/index.js","../Browser.Tabs.OnCreated/index.js":"../output/Browser.Tabs.OnCreated/index.js","../Data.Foldable/index.js":"../output/Data.Foldable/index.js","../Data.List.Types/index.js":"../output/Data.List.Types/index.js","../Data.Number.Format/index.js":"../output/Data.Number.Format/index.js","../Effect/index.js":"../output/Effect/index.js","../Effect.Console/index.js":"../output/Effect.Console/index.js","../Effect.Ref/index.js":"../output/Effect.Ref/index.js"}],"background.js":[function(require,module,exports) {
var Background = require("../output/PureTabs.Background");

function main() {
  Background.main();
}

main();
},{"../output/PureTabs.Background":"../output/PureTabs.Background/index.js"}],"../node_modules/parcel/src/builtins/hmr-runtime.js":[function(require,module,exports) {
var global = arguments[3];
var OVERLAY_ID = '__parcel__error__overlay__';
var OldModule = module.bundle.Module;

function Module(moduleName) {
  OldModule.call(this, moduleName);
  this.hot = {
    data: module.bundle.hotData,
    _acceptCallbacks: [],
    _disposeCallbacks: [],
    accept: function (fn) {
      this._acceptCallbacks.push(fn || function () {});
    },
    dispose: function (fn) {
      this._disposeCallbacks.push(fn);
    }
  };
  module.bundle.hotData = null;
}

module.bundle.Module = Module;
var checkedAssets, assetsToAccept;
var parent = module.bundle.parent;

if ((!parent || !parent.isParcelRequire) && typeof WebSocket !== 'undefined') {
  var hostname = "" || location.hostname;
  var protocol = location.protocol === 'https:' ? 'wss' : 'ws';
  var ws = new WebSocket(protocol + '://' + hostname + ':' + "34255" + '/');

  ws.onmessage = function (event) {
    checkedAssets = {};
    assetsToAccept = [];
    var data = JSON.parse(event.data);

    if (data.type === 'update') {
      var handled = false;
      data.assets.forEach(function (asset) {
        if (!asset.isNew) {
          var didAccept = hmrAcceptCheck(global.parcelRequire, asset.id);

          if (didAccept) {
            handled = true;
          }
        }
      }); // Enable HMR for CSS by default.

      handled = handled || data.assets.every(function (asset) {
        return asset.type === 'css' && asset.generated.js;
      });

      if (handled) {
        console.clear();
        data.assets.forEach(function (asset) {
          hmrApply(global.parcelRequire, asset);
        });
        assetsToAccept.forEach(function (v) {
          hmrAcceptRun(v[0], v[1]);
        });
      } else if (location.reload) {
        // `location` global exists in a web worker context but lacks `.reload()` function.
        location.reload();
      }
    }

    if (data.type === 'reload') {
      ws.close();

      ws.onclose = function () {
        location.reload();
      };
    }

    if (data.type === 'error-resolved') {
      console.log('[parcel] ✨ Error resolved');
      removeErrorOverlay();
    }

    if (data.type === 'error') {
      console.error('[parcel] 🚨  ' + data.error.message + '\n' + data.error.stack);
      removeErrorOverlay();
      var overlay = createErrorOverlay(data);
      document.body.appendChild(overlay);
    }
  };
}

function removeErrorOverlay() {
  var overlay = document.getElementById(OVERLAY_ID);

  if (overlay) {
    overlay.remove();
  }
}

function createErrorOverlay(data) {
  var overlay = document.createElement('div');
  overlay.id = OVERLAY_ID; // html encode message and stack trace

  var message = document.createElement('div');
  var stackTrace = document.createElement('pre');
  message.innerText = data.error.message;
  stackTrace.innerText = data.error.stack;
  overlay.innerHTML = '<div style="background: black; font-size: 16px; color: white; position: fixed; height: 100%; width: 100%; top: 0px; left: 0px; padding: 30px; opacity: 0.85; font-family: Menlo, Consolas, monospace; z-index: 9999;">' + '<span style="background: red; padding: 2px 4px; border-radius: 2px;">ERROR</span>' + '<span style="top: 2px; margin-left: 5px; position: relative;">🚨</span>' + '<div style="font-size: 18px; font-weight: bold; margin-top: 20px;">' + message.innerHTML + '</div>' + '<pre>' + stackTrace.innerHTML + '</pre>' + '</div>';
  return overlay;
}

function getParents(bundle, id) {
  var modules = bundle.modules;

  if (!modules) {
    return [];
  }

  var parents = [];
  var k, d, dep;

  for (k in modules) {
    for (d in modules[k][1]) {
      dep = modules[k][1][d];

      if (dep === id || Array.isArray(dep) && dep[dep.length - 1] === id) {
        parents.push(k);
      }
    }
  }

  if (bundle.parent) {
    parents = parents.concat(getParents(bundle.parent, id));
  }

  return parents;
}

function hmrApply(bundle, asset) {
  var modules = bundle.modules;

  if (!modules) {
    return;
  }

  if (modules[asset.id] || !bundle.parent) {
    var fn = new Function('require', 'module', 'exports', asset.generated.js);
    asset.isNew = !modules[asset.id];
    modules[asset.id] = [fn, asset.deps];
  } else if (bundle.parent) {
    hmrApply(bundle.parent, asset);
  }
}

function hmrAcceptCheck(bundle, id) {
  var modules = bundle.modules;

  if (!modules) {
    return;
  }

  if (!modules[id] && bundle.parent) {
    return hmrAcceptCheck(bundle.parent, id);
  }

  if (checkedAssets[id]) {
    return;
  }

  checkedAssets[id] = true;
  var cached = bundle.cache[id];
  assetsToAccept.push([bundle, id]);

  if (cached && cached.hot && cached.hot._acceptCallbacks.length) {
    return true;
  }

  return getParents(global.parcelRequire, id).some(function (id) {
    return hmrAcceptCheck(global.parcelRequire, id);
  });
}

function hmrAcceptRun(bundle, id) {
  var cached = bundle.cache[id];
  bundle.hotData = {};

  if (cached) {
    cached.hot.data = bundle.hotData;
  }

  if (cached && cached.hot && cached.hot._disposeCallbacks.length) {
    cached.hot._disposeCallbacks.forEach(function (cb) {
      cb(bundle.hotData);
    });
  }

  delete bundle.cache[id];
  bundle(id);
  cached = bundle.cache[id];

  if (cached && cached.hot && cached.hot._acceptCallbacks.length) {
    cached.hot._acceptCallbacks.forEach(function (cb) {
      cb();
    });

    return true;
  }
}
},{}]},{},["../node_modules/parcel/src/builtins/hmr-runtime.js","background.js"], null)
//# sourceMappingURL=/background.js.map