sury/src/S.res.js

🧬 The fastest schema with next-gen DX

'use strict';

function some(x) {
  if (x === undefined) {
    return {
            BS_PRIVATE_NESTED_SOME_NONE: 0
          };
  } else if (x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== undefined) {
    return {
            BS_PRIVATE_NESTED_SOME_NONE: x.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0
          };
  } else {
    return x;
  }
}

function valFromOption(x) {
  if (!(x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== undefined)) {
    return x;
  }
  var depth = x.BS_PRIVATE_NESTED_SOME_NONE;
  if (depth === 0) {
    return ;
  } else {
    return {
            BS_PRIVATE_NESTED_SOME_NONE: depth - 1 | 0
          };
  }
}
/* No side effect */

function length$1(xs) {
  var _x = xs;
  var _acc = 0;
  while(true) {
    var acc = _acc;
    var x = _x;
    if (!x) {
      return acc;
    }
    _acc = acc + 1 | 0;
    _x = x.tl;
    continue ;
  }}

function fillAux(arr, _i, _x) {
  while(true) {
    var x = _x;
    var i = _i;
    if (!x) {
      return ;
    }
    arr[i] = x.hd;
    _x = x.tl;
    _i = i + 1 | 0;
    continue ;
  }}

function fromArray$1(a) {
  var _i = a.length - 1 | 0;
  var _res = /* [] */0;
  while(true) {
    var res = _res;
    var i = _i;
    if (i < 0) {
      return res;
    }
    _res = {
      hd: a[i],
      tl: res
    };
    _i = i - 1 | 0;
    continue ;
  }}

function toArray$1(x) {
  var len = length$1(x);
  var arr = new Array(len);
  fillAux(arr, 0, x);
  return arr;
}
/* No side effect */

// Generated by ReScript, PLEASE EDIT WITH CARE


function classify(arrayable) {
  if (Array.isArray(arrayable)) {
    return {
            TAG: "Array",
            _0: arrayable
          };
  } else {
    return {
            TAG: "Single",
            _0: arrayable
          };
  }
}

var Arrayable = {
  classify: classify
};
/* No side effect */

var idMap = new Map();

function create(str) {
  var v = idMap.get(str);
  var id;
  if (v !== undefined) {
    var id$1 = v + 1 | 0;
    idMap.set(str, id$1);
    id = id$1;
  } else {
    idMap.set(str, 1);
    id = 1;
  }
  return str + ("/" + id);
}
/* idMap Not a pure module */

// Generated by ReScript, PLEASE EDIT WITH CARE

var immutableEmpty = {};

var immutableEmpty$1 = [];

function fromString(string) {
  var _idx = 0;
  while(true) {
    var idx = _idx;
    var match = string[idx];
    if (match === undefined) {
      return "\"" + string + "\"";
    }
    if (match === "\"") {
      return JSON.stringify(string);
    }
    _idx = idx + 1 | 0;
    continue ;
  }}

function toArray(path) {
  if (path === "") {
    return [];
  } else {
    return JSON.parse(path.split("\"][\"").join("\",\""));
  }
}

function fromLocation($$location) {
  return "[" + fromString($$location) + "]";
}

function fromArray(array) {
  var len = array.length;
  if (len !== 1) {
    if (len !== 0) {
      return "[" + array.map(fromString).join("][") + "]";
    } else {
      return "";
    }
  }
  var $$location = array[0];
  return "[" + fromString($$location) + "]";
}

function concat(path, concatedPath) {
  return path + concatedPath;
}

var vendor = "sury";

var s = Symbol(vendor);

var itemSymbol = Symbol(vendor + ":item");

var $$Error$1 = /* @__PURE__ */create("Sury.Error");

var isLiteral = (s => "const" in s);

function isOptional(schema) {
  var match = schema.type;
  switch (match) {
    case "undefined" :
        return true;
    case "union" :
        return schema.has["undefined"];
    default:
      return false;
  }
}

var globalConfig = {
  r: 0,
  a: "strip",
  n: false
};

class SuryError extends Error {
  constructor(code, flag, path) {
    super();
    this.flag = flag;
    this.code = code;
    this.path = path;
  }
}

var d = Object.defineProperty, p = SuryError.prototype;
d(p, 'message', {
  get() {
      return message(this);
  }
});
d(p, 'reason', {
  get() {
      return reason(this);
  }
});
d(p, 'name', {value: 'SuryError'});
d(p, 's', {value: s});
d(p, '_1', {
  get() {
    return this
  },
});
d(p, 'RE_EXN_ID', {
  value: $$Error$1,
});

var Schema$1 = function() {}, sp = Object.create(null);
d(sp, 'with', {
  get() {
    return (fn, ...args) => fn(this, ...args)
  },
});
// Also has ~standard below
Schema$1.prototype = sp;

function getOrRethrow(exn) {
  if ((exn&&exn.s===s)) {
    return exn;
  }
  throw exn;
}

function has(acc, flag) {
  return (acc & flag) !== 0;
}

var copy = ((schema) => {
  let c = new Schema$1();
  for (let k in schema) {
    if (k > "a") {
      c[k] = schema[k];
    }
  }
  return c
});

var mergeInPlace = ((target, schema) => {
  for (let k in schema) {
    if (k > "a") {
      target[k] = schema[k];
    }
  }
});

var resetOperationsCache = ((schema) => {
  for (let k in schema) {
    if (+k) {
      delete schema[k];
    }
  }
});

function stringify(unknown) {
  var typeOfValue = typeof unknown;
  if (typeOfValue === "number" || typeOfValue === "function" || typeOfValue === "boolean" || typeOfValue === "symbol") {
    return unknown.toString();
  }
  if (typeOfValue === "string") {
    return "\"" + unknown + "\"";
  }
  if (typeOfValue !== "object") {
    if (typeOfValue === "undefined") {
      return "undefined";
    } else {
      return unknown + "n";
    }
  }
  if (unknown === null) {
    return "null";
  }
  if (Array.isArray(unknown)) {
    var string = "[";
    for(var i = 0 ,i_finish = unknown.length; i < i_finish; ++i){
      if (i !== 0) {
        string = string + ", ";
      }
      string = string + stringify(unknown[i]);
    }
    return string + "]";
  }
  if (unknown.constructor !== Object) {
    return Object.prototype.toString.call(unknown);
  }
  var keys = Object.keys(unknown);
  var string$1 = "{ ";
  for(var i$1 = 0 ,i_finish$1 = keys.length; i$1 < i_finish$1; ++i$1){
    var key = keys[i$1];
    var value = unknown[key];
    string$1 = string$1 + key + ": " + stringify(value) + "; ";
  }
  return string$1 + "}";
}

function toExpression$1(schema) {
  var tag = schema.type;
  var $$const = schema.const;
  var name = schema.name;
  if (name !== undefined) {
    return name;
  }
  if ($$const !== undefined) {
    return stringify($$const);
  }
  var format = schema.format;
  var anyOf = schema.anyOf;
  if (anyOf !== undefined) {
    return anyOf.map(toExpression$1).join(" | ");
  }
  if (format !== undefined) {
    return format;
  }
  switch (tag) {
    case "nan" :
        return "NaN";
    case "instance" :
        return schema.class.name;
    case "array" :
        var additionalItems = schema.additionalItems;
        var items = schema.items;
        if (typeof additionalItems !== "object") {
          return "[" + items.map(function (item) {
                        return toExpression$1(item.schema);
                      }).join(", ") + "]";
        }
        var itemName = toExpression$1(additionalItems);
        return (
                additionalItems.type === "union" ? "(" + itemName + ")" : itemName
              ) + "[]";
    case "object" :
        var additionalItems$1 = schema.additionalItems;
        var items$1 = schema.items;
        if (items$1.length === 0) {
          if (typeof additionalItems$1 === "object") {
            return "{ [key: string]: " + toExpression$1(additionalItems$1) + "; }";
          } else {
            return "{}";
          }
        } else {
          return "{ " + items$1.map(function (item) {
                        return item.location + ": " + toExpression$1(item.schema) + ";";
                      }).join(" ") + " }";
        }
    default:
      return tag;
  }
}

var value = SuryError;

function constructor(prim0, prim1, prim2) {
  return new SuryError(prim0, prim1, prim2);
}

function reason(error, nestedLevelOpt) {
  var nestedLevel = nestedLevelOpt !== undefined ? nestedLevelOpt : 0;
  var reason$1 = error.code;
  if (typeof reason$1 !== "object") {
    return "Encountered unexpected async transform or refine. Use parseAsyncOrThrow operation instead";
  }
  switch (reason$1.TAG) {
    case "OperationFailed" :
        return reason$1._0;
    case "InvalidOperation" :
        return reason$1.description;
    case "InvalidType" :
        var unionErrors = reason$1.unionErrors;
        var m = "Expected " + toExpression$1(reason$1.expected) + ", received " + stringify(reason$1.received);
        if (unionErrors !== undefined) {
          var lineBreak = "\n" + " ".repeat((nestedLevel << 1));
          var reasonsDict = {};
          for(var idx = 0 ,idx_finish = unionErrors.length; idx < idx_finish; ++idx){
            var error$1 = unionErrors[idx];
            var reason$2 = reason(error$1, nestedLevel + 1);
            var nonEmptyPath = error$1.path;
            var $$location = nonEmptyPath === "" ? "" : "At " + nonEmptyPath + ": ";
            var line = "- " + $$location + reason$2;
            if (!reasonsDict[line]) {
              reasonsDict[line] = 1;
              m = m + lineBreak + line;
            }
            
          }
        }
        return m;
    case "ExcessField" :
        return "Unrecognized key \"" + reason$1._0 + "\"";
    case "InvalidJsonSchema" :
        return toExpression$1(reason$1._0) + " is not valid JSON";
    
  }
}

function reason$1(error) {
  return reason(error, undefined);
}

function message(error) {
  var op = error.flag;
  var text = "Failed ";
  if (op & 2) {
    text = text + "async ";
  }
  text = text + (
    op & 1 ? (
        op & 4 ? "asserting" : "parsing"
      ) : "converting"
  );
  if (op & 8) {
    text = text + " to JSON" + (
      op & 16 ? " string" : ""
    );
  }
  var nonEmptyPath = error.path;
  var tmp = nonEmptyPath === "" ? "" : " at " + nonEmptyPath;
  return text + tmp + ": " + reason(error, undefined);
}

var ErrorClass$1 = {
  value: value,
  constructor: constructor,
  reason: reason$1,
  message: message
};

function embed(b, value) {
  var e = b.g.e;
  var l = e.length;
  e[l] = value;
  return "e[" + l + "]";
}

function inlineConst(b, schema) {
  var match = schema.type;
  switch (match) {
    case "string" :
        var $$const = schema.const;
        return fromString($$const);
    case "bigint" :
        var $$const$1 = schema.const;
        return $$const$1 + "n";
    case "undefined" :
        return "void 0";
    case "symbol" :
    case "function" :
    case "instance" :
        break;
    default:
      return schema.const;
  }
  var $$const$2 = schema.const;
  return embed(b, $$const$2);
}

function secondAllocate(v) {
  var b = this;
  b.l = b.l + "," + v;
}

function initialAllocate(v) {
  var b = this;
  b.l = v;
  b.a = secondAllocate;
}

function rootScope(flag) {
  var $$global = {
    c: "",
    l: "",
    a: initialAllocate,
    v: -1,
    o: flag,
    e: []
  };
  $$global.g = $$global;
  return $$global;
}

function allocateScope(b) {
  ((delete b.a));
  var varsAllocation = b.l;
  if (varsAllocation === "") {
    return b.c;
  } else {
    return "let " + varsAllocation + ";" + b.c;
  }
}

function varWithoutAllocation($$global) {
  var newCounter = $$global.v + 1;
  $$global.v = newCounter;
  return "v" + newCounter;
}

function _var(_b) {
  return this.i;
}

function _notVar(b) {
  var val = this;
  var v = varWithoutAllocation(b.g);
  var i = val.i;
  if (i === "") {
    val.b.a(v);
  } else if (val.b.a !== (void 0)) {
    val.b.a(v + "=" + i);
  } else {
    b.c = b.c + (v + "=" + i + ";");
    b.g.a(v);
  }
  val.v = _var;
  val.i = v;
  return v;
}

function allocateVal(b) {
  var v = varWithoutAllocation(b.g);
  b.a(v);
  return {
          b: b,
          v: _var,
          i: v,
          a: false
        };
}

function objectJoin(inlinedLocation, value) {
  return inlinedLocation + ":" + value + ",";
}

function arrayJoin(_inlinedLocation, value) {
  return value + ",";
}

function make(b, isArray) {
  return {
          b: b,
          v: _notVar,
          i: "",
          a: false,
          j: isArray ? arrayJoin : objectJoin,
          c: 0,
          p: ""
        };
}

function add(objectVal, inlinedLocation, val) {
  objectVal[inlinedLocation] = val;
  if (val.a) {
    objectVal.p = objectVal.p + val.i + ",";
    objectVal.i = objectVal.i + objectVal.j(inlinedLocation, "a[" + (objectVal.c++) + "]");
  } else {
    objectVal.i = objectVal.i + objectVal.j(inlinedLocation, val.i);
  }
}

function merge(target, subObjectVal) {
  var inlinedLocations = Object.keys(subObjectVal);
  for(var idx = 7 ,idx_finish = inlinedLocations.length; idx < idx_finish; ++idx){
    var inlinedLocation = inlinedLocations[idx];
    add(target, inlinedLocation, subObjectVal[inlinedLocation]);
  }
}

function complete(objectVal, isArray) {
  objectVal.i = isArray ? "[" + objectVal.i + "]" : "{" + objectVal.i + "}";
  if (objectVal.c) {
    objectVal.a = true;
    objectVal.i = "Promise.all([" + objectVal.p + "]).then(a=>(" + objectVal.i + "))";
  }
  return objectVal;
}

function addKey(b, input, key, val) {
  return input.v(b) + "[" + key + "]=" + val.i;
}

function set(b, input, val) {
  if (input === val) {
    return "";
  }
  var inputVar = input.v(b);
  var match = input.a;
  if (match) {
    var match$1 = val.a;
    if (!match$1) {
      return inputVar + "=Promise.resolve(" + val.i + ")";
    }
    
  } else {
    var match$2 = val.a;
    if (match$2) {
      input.a = true;
      return inputVar + "=" + val.i;
    }
    
  }
  return inputVar + "=" + val.i;
}

function get(b, targetVal, inlinedLocation) {
  var val = targetVal[inlinedLocation];
  if (val !== undefined) {
    return val;
  } else {
    return {
            b: b,
            v: _notVar,
            i: targetVal.v(b) + ("[" + inlinedLocation + "]"),
            a: false
          };
  }
}

function setInlined(b, input, inlined) {
  return input.v(b) + "=" + inlined;
}

function map(inlinedFn, input) {
  return {
          b: input.b,
          v: _notVar,
          i: inlinedFn + "(" + input.i + ")",
          a: false
        };
}

function transform$1(b, input, operation) {
  if (!input.a) {
    return operation(b, input);
  }
  var bb = {
    c: "",
    l: "",
    a: initialAllocate,
    g: b.g
  };
  var operationInput = {
    b: b,
    v: _var,
    i: varWithoutAllocation(bb.g),
    a: false
  };
  var operationOutputVal = operation(bb, operationInput);
  var operationCode = allocateScope(bb);
  return {
          b: input.b,
          v: _notVar,
          i: input.i + ".then(" + operationInput.v(b) + "=>{" + operationCode + "return " + operationOutputVal.i + "})",
          a: true
        };
}

function raise(b, code, path) {
  throw new SuryError(code, b.g.o, path);
}

function embedSyncOperation(b, input, fn) {
  if (input.a) {
    return {
            b: input.b,
            v: _notVar,
            i: input.i + ".then(" + embed(b, fn) + ")",
            a: true
          };
  } else {
    return map(embed(b, fn), input);
  }
}

function failWithArg(b, path, fn, arg) {
  return embed(b, (function (arg) {
                return raise(b, fn(arg), path);
              })) + "(" + arg + ")";
}

function fail(b, message, path) {
  return embed(b, (function () {
                return raise(b, {
                            TAG: "OperationFailed",
                            _0: message
                          }, path);
              })) + "()";
}

function effectCtx(b, selfSchema, path) {
  return {
          schema: selfSchema,
          fail: (function (message, customPathOpt) {
              var customPath = customPathOpt !== undefined ? customPathOpt : "";
              return raise(b, {
                          TAG: "OperationFailed",
                          _0: message
                        }, path + customPath);
            })
        };
}

function invalidOperation(b, path, description) {
  return raise(b, {
              TAG: "InvalidOperation",
              description: description
            }, path);
}

function withCatch(b, input, $$catch, appendSafe, fn) {
  var prevCode = b.c;
  b.c = "";
  var errorVar = varWithoutAllocation(b.g);
  var maybeResolveVal = $$catch(b, errorVar);
  var catchCode = "if(" + (errorVar + "&&" + errorVar + ".s===s") + "){" + b.c;
  b.c = "";
  var bb = {
    c: "",
    l: "",
    a: initialAllocate,
    g: b.g
  };
  var fnOutput = fn(bb);
  b.c = b.c + allocateScope(bb);
  var isNoop = fnOutput.i === input.i && b.c === "";
  if (appendSafe !== undefined) {
    appendSafe(b, fnOutput);
  }
  if (isNoop) {
    return fnOutput;
  }
  var isAsync = fnOutput.a;
  var output = input === fnOutput ? input : (
      appendSafe !== undefined ? fnOutput : ({
            b: b,
            v: _notVar,
            i: "",
            a: isAsync
          })
    );
  var catchCode$1 = maybeResolveVal !== undefined ? (function (catchLocation) {
        return catchCode + (
                catchLocation === 1 ? "return " + maybeResolveVal.i : set(b, output, maybeResolveVal)
              ) + ("}else{throw " + errorVar + "}");
      }) : (function (param) {
        return catchCode + "}throw " + errorVar;
      });
  b.c = prevCode + ("try{" + b.c + (
      isAsync ? setInlined(b, output, fnOutput.i + ".catch(" + errorVar + "=>{" + catchCode$1(1) + "})") : set(b, output, fnOutput)
    ) + "}catch(" + errorVar + "){" + catchCode$1(0) + "}");
  return output;
}

function withPathPrepend(b, input, path, maybeDynamicLocationVar, appendSafe, fn) {
  if (path === "" && maybeDynamicLocationVar === undefined) {
    return fn(b, input, path);
  }
  try {
    return withCatch(b, input, (function (b, errorVar) {
                  b.c = errorVar + ".path=" + fromString(path) + "+" + (
                    maybeDynamicLocationVar !== undefined ? "'[\"'+" + maybeDynamicLocationVar + "+'\"]'+" : ""
                  ) + errorVar + ".path";
                }), appendSafe, (function (b) {
                  return fn(b, input, "");
                }));
  }
  catch (exn){
    var error = getOrRethrow(exn);
    throw new SuryError(error.code, error.flag, path + "[]" + error.path);
  }
}

function validation(b, inputVar, schema, negative) {
  var eq = negative ? "!==" : "===";
  var and_ = negative ? "||" : "&&";
  var exp = negative ? "!" : "";
  var tag = schema.type;
  switch (tag) {
    case "null" :
        return inputVar + eq + "null";
    case "undefined" :
        return inputVar + eq + "void 0";
    case "nan" :
        return exp + ("Number.isNaN(" + inputVar + ")");
    default:
      var match = schema.const;
      if (match !== undefined) {
        return inputVar + eq + inlineConst(b, schema);
      }
      switch (tag) {
        case "instance" :
            var $$class = schema.class;
            var c = inputVar + " instanceof " + embed(b, $$class);
            if (negative) {
              return "!(" + c + ")";
            } else {
              return c;
            }
        case "array" :
            return exp + "Array.isArray(" + inputVar + ")";
        case "object" :
            return "typeof " + inputVar + eq + "\"" + tag + "\"" + and_ + exp + inputVar;
        default:
          return "typeof " + inputVar + eq + "\"" + tag + "\"";
      }
  }
}

function refinement(b, inputVar, schema, negative) {
  var eq = negative ? "!==" : "===";
  var and_ = negative ? "||" : "&&";
  var not_ = negative ? "" : "!";
  var lt = negative ? ">" : "<";
  var gt = negative ? "<" : ">";
  var match = schema.type;
  var tag;
  var exit = 0;
  var match$1 = schema.const;
  if (match$1 !== undefined) {
    return "";
  }
  var match$2 = schema.format;
  if (match$2 !== undefined) {
    if (match$2 === "int32") {
      return and_ + inputVar + lt + "2147483647" + and_ + inputVar + gt + "-2147483648" + and_ + inputVar + "%1" + eq + "0";
    }
    exit = 2;
  } else {
    exit = 2;
  }
  if (exit === 2) {
    switch (match) {
      case "number" :
          if (globalConfig.n) {
            return "";
          } else {
            return and_ + not_ + "Number.isNaN(" + inputVar + ")";
          }
      case "array" :
      case "object" :
          tag = match;
          break;
      default:
        return "";
    }
  }
  var additionalItems = schema.additionalItems;
  var items = schema.items;
  var length = items.length;
  var code = tag === "array" ? (
      additionalItems === "strip" || additionalItems === "strict" ? (
          additionalItems === "strip" ? and_ + inputVar + ".length" + gt + length : and_ + inputVar + ".length" + eq + length
        ) : ""
    ) : (
      additionalItems === "strip" ? "" : and_ + not_ + "Array.isArray(" + inputVar + ")"
    );
  for(var idx = 0 ,idx_finish = items.length; idx < idx_finish; ++idx){
    var match$3 = items[idx];
    var inlinedLocation = match$3.inlinedLocation;
    var item = match$3.schema;
    var itemCode;
    if (isLiteral(item) && !item.catch || schema.unnest) {
      itemCode = validation(b, inputVar + ("[" + inlinedLocation + "]"), item, negative);
    } else if (item.type === "object") {
      var inputVar$1 = inputVar + ("[" + inlinedLocation + "]");
      itemCode = validation(b, inputVar$1, item, negative) + refinement(b, inputVar$1, item, negative);
    } else {
      itemCode = "";
    }
    if (itemCode !== "") {
      code = code + and_ + itemCode;
    }
    
  }
  return code;
}

function typeFilterCode(b, schema, input, path) {
  var match = schema.type;
  var match$1 = schema.noValidation;
  if (match$1 !== undefined && match$1) {
    return "";
  }
  switch (match) {
    case "never" :
    case "unknown" :
    case "union" :
    case "json" :
        return "";
    default:
      var inputVar = input.v(b);
      return "if(" + validation(b, inputVar, schema, true) + refinement(b, inputVar, schema, true) + "){" + failWithArg(b, path, (function (input) {
                    return {
                            TAG: "InvalidType",
                            expected: schema,
                            received: input
                          };
                  }), inputVar) + "}";
  }
}

function parse(b, schema, input, path) {
  var builder = schema.builder;
  if (builder !== undefined) {
    return builder(b, input, schema, path);
  } else {
    return input;
  }
}

function parseWithTypeValidation(b, schema, input, path) {
  if (b.g.o & 1 || isLiteral(schema)) {
    b.c = b.c + typeFilterCode(b, schema, input, path);
  }
  return parse(b, schema, input, path);
}

function noopOperation(i) {
  return i;
}

var nonJsonableTags = new Set([
      "unknown",
      "nan",
      "bigint",
      "function",
      "instance",
      "symbol"
    ]);

function jsonableValidation(output, parent, path, flag, recSet) {
  var tag = output.type;
  if (tag === "undefined" && parent.type !== "object" || nonJsonableTags.has(tag)) {
    throw new SuryError({
              TAG: "InvalidJsonSchema",
              _0: parent
            }, flag, path);
  }
  var match = output.type;
  switch (match) {
    case "array" :
    case "object" :
    case "union" :
        break;
    default:
      return ;
  }
  var recSet$1 = recSet !== undefined ? valFromOption(recSet) : new Set();
  if (recSet$1.has(output)) {
    return ;
  }
  recSet$1.add(output);
  var recSet$2 = some(recSet$1);
  if (tag === "union") {
    output.anyOf.forEach(function (s) {
          jsonableValidation(s, parent, path, flag, recSet$2);
        });
    return ;
  }
  var additionalItems = output.additionalItems;
  var items = output.items;
  if (items === undefined) {
    return ;
  }
  if (additionalItems === "strip" || additionalItems === "strict") ; else {
    jsonableValidation(additionalItems, parent, path, flag, recSet$2);
  }
  items.forEach(function (item) {
        jsonableValidation(item.schema, output, path + ("[" + item.inlinedLocation + "]"), flag, recSet$2);
      });
}

function reverse$1(schema) {
  var fn = schema.output;
  if (fn === undefined) {
    return schema;
  }
  if (typeof fn === "object") {
    return fn;
  }
  var reversed = fn.call(schema);
  var reversed$1 = reversed.output === undefined ? copy(reversed) : reversed;
  schema.output = reversed$1;
  reversed$1.output = schema;
  return reversed$1;
}

function internalCompile(schema, flag) {
  var b = rootScope(flag);
  if (flag & 8) {
    var output = reverse$1(schema);
    jsonableValidation(output, output, "", flag, undefined);
  }
  var input = {
    b: b,
    v: _var,
    i: "i",
    a: false
  };
  var output$1 = parse(b, schema, input, "");
  schema.isAsync = output$1.a;
  if (b.l !== "") {
    b.c = "let " + b.l + ";" + b.c;
  }
  if (flag & 1 || isLiteral(schema)) {
    b.c = typeFilterCode(b, schema, input, "") + b.c;
  }
  if (b.c === "" && output$1 === input && !(flag & 22)) {
    return noopOperation;
  }
  var inlinedOutput = flag & 4 ? "void 0" : output$1.i;
  if (flag & 16) {
    inlinedOutput = "JSON.stringify(" + inlinedOutput + ")";
  }
  if (flag & 2 && !output$1.a) {
    inlinedOutput = "Promise.resolve(" + inlinedOutput + ")";
  }
  var inlinedFunction = "i=>{" + b.c + "return " + inlinedOutput + "}";
  return new Function("e", "s", "return " + inlinedFunction)(b.g.e, s);
}

function operationFn(s, o) {
  if ((o in s)) {
    return (s[o]);
  }
  var f = internalCompile(o & 32 ? reverse$1(s) : s, o);
  ((s[o] = f));
  return f;
}

d(sp, "~standard", {
      get: (function () {
          var schema = this;
          return {
                  version: 1,
                  vendor: vendor,
                  validate: (function (input) {
                      try {
                        return {
                                value: operationFn(schema, 1)(input)
                              };
                      }
                      catch (exn){
                        var error = getOrRethrow(exn);
                        return {
                                issues: [{
                                    message: message(error),
                                    path: error.path === "" ? undefined : toArray(error.path)
                                  }]
                              };
                      }
                    })
                };
        })
    });

function compile$1(schema, input, output, mode, typeValidationOpt) {
  var typeValidation = typeValidationOpt !== undefined ? typeValidationOpt : true;
  var flag = 0;
  var exit = 0;
  switch (output) {
    case "Output" :
    case "Input" :
        exit = 1;
        break;
    case "Assert" :
        flag = flag | 4;
        break;
    case "Json" :
        flag = flag | 8;
        break;
    case "JsonString" :
        flag = flag | 24;
        break;
    
  }
  if (exit === 1 && output === input) {
    throw new Error("[Sury] Can't compile operation to converting value to self");
  }
  if (mode !== "Sync") {
    flag = flag | 2;
  }
  if (typeValidation) {
    flag = flag | 1;
  }
  if (input === "Output") {
    flag = flag | 32;
  }
  var fn = operationFn(schema, flag);
  if (input !== "JsonString") {
    return fn;
  }
  var flag$1 = flag;
  return function (jsonString) {
    try {
      return fn(JSON.parse(jsonString));
    }
    catch (exn){
      throw new SuryError({
                TAG: "OperationFailed",
                _0: exn.message
              }, flag$1, "");
    }
  };
}

function item(factory, item$1) {
  return function () {
    var reversed = reverse$1(item$1);
    if (reversed === item$1) {
      return this;
    } else {
      return factory(reversed);
    }
  };
}

function parseOrThrow$1(any, schema) {
  return operationFn(schema, 1)(any);
}

function parseJsonStringOrThrow$1(jsonString, schema) {
  var tmp;
  try {
    tmp = JSON.parse(jsonString);
  }
  catch (exn){
    throw new SuryError({
              TAG: "OperationFailed",
              _0: exn.message
            }, 1, "");
  }
  return parseOrThrow$1(tmp, schema);
}

function parseAsyncOrThrow$1(any, schema) {
  return operationFn(schema, 3)(any);
}

function convertOrThrow$1(input, schema) {
  return operationFn(schema, 0)(input);
}

function convertToJsonOrThrow$1(any, schema) {
  return operationFn(schema, 8)(any);
}

function convertToJsonStringOrThrow$1(input, schema) {
  return operationFn(schema, 24)(input);
}

function convertAsyncOrThrow$1(any, schema) {
  return operationFn(schema, 2)(any);
}

function reverseConvertOrThrow$1(value, schema) {
  return operationFn(schema, 32)(value);
}

function reverseConvertToJsonOrThrow$1(value, schema) {
  return operationFn(schema, 40)(value);
}

function reverseConvertToJsonStringOrThrow$1(value, schema, spaceOpt) {
  var space = spaceOpt !== undefined ? spaceOpt : 0;
  return JSON.stringify(reverseConvertToJsonOrThrow$1(value, schema), null, space);
}

function assertOrThrow$1(any, schema) {
  return operationFn(schema, 5)(any);
}

var $$undefined = new Schema$1();

$$undefined.type = "undefined";

$$undefined.const = (void 0);

var $$null$1 = new Schema$1();

$$null$1.type = "null";

$$null$1.const = null;

function parse$1(value) {
  if (value === null) {
    return $$null$1;
  }
  var $$typeof = typeof value;
  var schema;
  if ($$typeof === "object") {
    var mut = new Schema$1();
    mut.type = "instance";
    var i = mut;
    i.class = value.constructor;
    schema = i;
  } else if ($$typeof === "undefined") {
    schema = $$undefined;
  } else if ($$typeof === "number") {
    if (Number.isNaN(value)) {
      var mut$1 = new Schema$1();
      mut$1.type = "nan";
      schema = mut$1;
    } else {
      var mut$2 = new Schema$1();
      mut$2.type = $$typeof;
      schema = mut$2;
    }
  } else {
    var mut$3 = new Schema$1();
    mut$3.type = $$typeof;
    schema = mut$3;
  }
  schema.const = value;
  return schema;
}

function isAsync$1(schema) {
  var v = schema.isAsync;
  if (v !== undefined) {
    return v;
  }
  try {
    var b = rootScope(2);
    var input = {
      b: b,
      v: _var,
      i: "i",
      a: false
    };
    var output = parse(b, schema, input, "");
    schema.isAsync = output.a;
    return output.a;
  }
  catch (exn){
    getOrRethrow(exn);
    return false;
  }
}

function make$1(namespace, name) {
  return "m:" + namespace + ":" + name;
}

function internal(name) {
  return "m:" + name;
}

var Id = {
  make: make$1,
  internal: internal
};

function get$1(schema, id) {
  return schema[id];
}

function set$1(schema, id, metadata) {
  var mut = copy(schema);
  mut[id] = metadata;
  return mut;
}

function recursive$1(fn) {
  var r = "r" + globalConfig.r;
  globalConfig.r = globalConfig.r + 1 | 0;
  var builder = function (b, input, param, param$1) {
    return transform$1(b, input, (function (_b, input) {
                  return map(r, input);
                }));
  };
  var output = function () {
    var mut = new Schema$1();
    mut.type = "unknown";
    mut.builder = (function (_b, input, param, param$1) {
        return map(r, input);
      });
    return mut;
  };
  var placeholder = new Schema$1();
  placeholder.type = "unknown";
  placeholder.builder = builder;
  placeholder.output = output;
  placeholder.name = "Self";
  var schema = fn(placeholder);
  mergeInPlace(placeholder, schema);
  placeholder.name = toExpression$1(schema);
  placeholder.builder = builder;
  placeholder.output = output;
  var initialParseOperationBuilder = schema.builder;
  schema.builder = (function (b, input, selfSchema, path) {
      var inputVar = input.v(b);
      var bb = {
        c: "",
        l: "",
        a: initialAllocate,
        g: b.g
      };
      var opOutput = initialParseOperationBuilder(bb, input, selfSchema, "");
      var opBodyCode = allocateScope(bb) + ("return " + opOutput.i);
      b.c = b.c + ("let " + r + "=" + inputVar + "=>{" + opBodyCode + "};");
      return withPathPrepend(b, input, path, undefined, undefined, (function (b, input, param) {
                    return transform$1(b, input, (function (_b, input) {
                                  var output = map(r, input);
                                  if (opOutput.a) {
                                    output.a = true;
                                    placeholder.builder = (function (b, input, param, param$1) {
                                        return transform$1(b, input, (function (_b, input) {
                                                      var output = map(r, input);
                                                      output.a = true;
                                                      return output;
                                                    }));
                                      });
                                  }
                                  return output;
                                }));
                  }));
    });
  var initialReverse = schema.output.bind(schema);
  schema.output = (function () {
      var initialReversed = initialReverse();
      var mut = copy(initialReversed);
      mut.output = schema;
      schema.output = mut;
      mut.builder = (function (b, input, selfSchema, path) {
          var inputVar = input.v(b);
          var bb = {
            c: "",
            l: "",
            a: initialAllocate,
            g: b.g
          };
          var initialInput = {
            b: bb,
            v: input.v,
            i: input.i,
            a: input.a
          };
          var opOutput = initialReversed.builder(bb, initialInput, selfSchema, "");
          var opBodyCode = allocateScope(bb) + ("return " + opOutput.i);
          b.c = b.c + ("let " + r + "=" + inputVar + "=>{" + opBodyCode + "};");
          return withPathPrepend(b, input, path, undefined, undefined, (function (_b, input, param) {
                        return map(r, input);
                      }));
        });
      return mut;
    });
  return schema;
}

function noValidation$1(schema, value) {
  var mut = copy(schema);
  mut.noValidation = value;
  return mut;
}

function internalRefine(schema, refiner) {
  var mut = copy(schema);
  mut.builder = (function (b, input, selfSchema, path) {
      return transform$1(b, parse(b, schema, input, path), (function (b, input) {
                    var bb = {
                      c: "",
                      l: "",
                      a: initialAllocate,
                      g: b.g
                    };
                    var rCode = refiner(bb, input.v(bb), selfSchema, path);
                    b.c = b.c + allocateScope(bb) + rCode;
                    return input;
                  }));
    });
  mut.output = (function () {
      var schema$1 = reverse$1(schema);
      var mut = copy(schema$1);
      mut.builder = (function (b, input, selfSchema, path) {
          return parse(b, schema$1, transform$1(b, input, (function (b, input) {
                            b.c = b.c + refiner(b, input.v(b), selfSchema, path);
                            return input;
                          })), path);
        });
      return mut;
    });
  return mut;
}

function refine$1(schema, refiner) {
  return internalRefine(schema, (function (b, inputVar, selfSchema, path) {
                return embed(b, refiner(effectCtx(b, selfSchema, path))) + "(" + inputVar + ");";
              }));
}

function addRefinement(schema, metadataId, refinement, refiner) {
  var refinements = schema[metadataId];
  return internalRefine(set$1(schema, metadataId, refinements !== undefined ? refinements.concat(refinement) : [refinement]), refiner);
}

function transform$1$1(schema, transformer) {
  var mut = copy(schema);
  mut.builder = (function (b, input, selfSchema, path) {
      var input$1 = parse(b, schema, input, path);
      var match = transformer(effectCtx(b, selfSchema, path));
      var parser = match.p;
      if (parser !== undefined) {
        if (match.a !== undefined) {
          return invalidOperation(b, path, "The S.transform doesn't allow parser and asyncParser at the same time. Remove parser in favor of asyncParser");
        } else {
          return embedSyncOperation(b, input$1, parser);
        }
      }
      var asyncParser = match.a;
      if (asyncParser !== undefined) {
        if (!(b.g.o & 2)) {
          raise(b, "UnexpectedAsync", "");
        }
        var val = embedSyncOperation(b, input$1, asyncParser);
        val.a = true;
        return val;
      } else if (match.s !== undefined) {
        return invalidOperation(b, path, "The S.transform parser is missing");
      } else {
        return input$1;
      }
    });
  mut.output = (function () {
      var schema$1 = reverse$1(schema);
      return {
              type: "unknown",
              builder: (function (b, input, selfSchema, path) {
                  var match = transformer(effectCtx(b, selfSchema, path));
                  var serializer = match.s;
                  if (serializer !== undefined) {
                    return parse(b, schema$1, embedSyncOperation(b, input, serializer), path);
                  } else if (match.a !== undefined || match.p !== undefined) {
                    return invalidOperation(b, path, "The S.transform serializer is missing");
                  } else {
                    return parse(b, schema$1, input, path);
                  }
                })
            };
    });
  mut.isAsync = undefined;
  return mut;
}

function output() {
  var mut = new Schema$1();
  mut.type = "undefined";
  mut.const = (void 0);
  mut.builder = (function (b, param, param$1, param$2) {
      return {
              b: b,
              v: _notVar,
              i: "null",
              a: false
            };
    });
  return mut;
}

var mut = new Schema$1();

mut.type = "null";

mut.const = null;

mut.builder = (function (b, param, param$1, param$2) {
    return {
            b: b,
            v: _notVar,
            i: "void 0",
            a: false
          };
  });

mut.output = output;

var unknown$1 = new Schema$1();

unknown$1.type = "unknown";

function builder(b, input, selfSchema, path) {
  b.c = b.c + failWithArg(b, path, (function (input) {
          return {
                  TAG: "InvalidType",
                  expected: selfSchema,
                  received: input
                };
        }), input.i) + ";";
  return input;
}

var never$1 = new Schema$1();

never$1.type = "never";

never$1.builder = builder;

function getItemCode(b, schema, input, output, deopt, path) {
  try {
    var bb = {
      c: "",
      l: "",
      a: initialAllocate,
      g: b.g
    };
    if (deopt) {
      bb.c = bb.c + typeFilterCode(bb, schema, input, path);
    }
    var itemOutput = parse(bb, schema, input, path);
    if (itemOutput !== input) {
      itemOutput.b = bb;
      if (schema.type === "unknown") {
        var reversed = reverse$1(schema);
        bb.c = bb.c + typeFilterCode(bb, reversed, itemOutput, path);
      }
      if (itemOutput.a) {
        output.a = true;
      }
      bb.c = bb.c + (output.v(b) + "=" + itemOutput.i);
    }
    return allocateScope(bb);
  }
  catch (exn){
    return "throw " + embed(b, getOrRethrow(exn));
  }
}

function isPriority(tag, byKey) {
  if ((tag === "array" || tag === "instance") && byKey["object"]) {
    return true;
  } else if (tag === "nan") {
    return byKey["number"];
  } else {
    return false;
  }
}

function builder$1(b, input, selfSchema, path) {
  var fail = function (caught) {
    return embed(b, (function (param) {
                  var args = arguments;
                  return raise(b, {
                              TAG: "InvalidType",
                              expected: selfSchema,
                              received: args[0],
                              unionErrors: args.length > 1 ? Array.from(args).slice(1) : undefined
                            }, path);
                })) + "(" + input.v(b) + caught + ")";
  };
  var schemas = selfSchema.anyOf;
  var typeValidation = b.g.o & 1;
  var initialInline = input.i;
  var deoptIdx = -1;
  var lastIdx = schemas.length - 1 | 0;
  var byKey = {};
  var keys = [];
  for(var idx = 0; idx <= lastIdx; ++idx){
    var schema = schemas[idx];
    var tag = schema.type;
    var exit = 0;
    switch (tag) {
      case "never" :
      case "unknown" :
      case "union" :
      case "json" :
          exit = 1;
          break;
      default:
        var key = tag === "instance" ? schema.class.name : tag;
        var arr = byKey[key];
        if (arr !== undefined) {
          if (tag !== "undefined" && tag !== "null" && tag !== "nan") {
            arr.push(schema);
          }
          
        } else {
          if (isPriority(tag, byKey)) {
            keys.unshift(key);
          } else {
            keys.push(key);
          }
          byKey[key] = [schema];
        }
    }
    if (exit === 1) {
      deoptIdx = idx;
      byKey = {};
      keys = [];
    }
    
  }
  var deoptIdx$1 = deoptIdx;
  var byKey$1 = byKey;
  var keys$1 = keys;
  var start = "";
  var end = "";
  var caught = "";
  var exit$1 = false;
  if (deoptIdx$1 !== -1) {
    for(var idx$1 = 0; idx$1 <= deoptIdx$1; ++idx$1){
      if (!exit$1) {
        var schema$1 = schemas[idx$1];
        var itemCode = getItemCode(b, schema$1, input, input, true, path);
        if (itemCode) {
          var errorVar = "e" + idx$1;
          start = start + ("try{" + itemCode + "}catch(" + errorVar + "){");
          end = "}" + end;
          caught = caught + "," + errorVar;
        } else {
          exit$1 = true;
        }
      }
      
    }
  }
  if (!exit$1) {
    var nextElse = false;
    var noop = "";
    for(var idx$2 = 0 ,idx_finish = keys$1.length; idx$2 < idx_finish; ++idx$2){
      var schemas$1 = byKey$1[keys$1[idx$2]];
      var inputVar = input.v(b);
      var isMultiple = schemas$1.length > 1;
      var firstSchema = schemas$1[0];
      var cond = "";
      var body;
      if (isMultiple) {
        var itemStart = "";
        var itemEnd = "";
        var itemNextElse = false;
        var itemNoop = "";
        var caught$1 = "";
        var byDiscriminant = {};
        var itemIdx = 0;
        var lastIdx$1 = schemas$1.length - 1 | 0;
        while(itemIdx <= lastIdx$1) {
          var schema$2 = schemas$1[itemIdx];
          var itemCond = (
            isLiteral(schema$2) ? validation(b, inputVar, schema$2, false) : ""
          ) + refinement(b, inputVar, schema$2, false).slice(2);
          var itemCode$1 = getItemCode(b, schema$2, input, input, false, path);
          if (itemCond) {
            if (itemCode$1) {
              var match = byDiscriminant[itemCond];
              if (match !== undefined) {
                if (typeof match === "string") {
                  byDiscriminant[itemCond] = [
                    match,
                    itemCode$1
                  ];
                } else {
                  match.push(itemCode$1);
                }
              } else {
                byDiscriminant[itemCond] = itemCode$1;
              }
            } else {
              itemNoop = itemNoop ? itemNoop + "||" + itemCond : itemCond;
            }
          }
          if (!itemCond || itemIdx === lastIdx$1) {
            var accedDiscriminants = Object.keys(byDiscriminant);
            for(var idx$3 = 0 ,idx_finish$1 = accedDiscriminants.length; idx$3 < idx_finish$1; ++idx$3){
              var discrim = accedDiscriminants[idx$3];
              var if_ = itemNextElse ? "else if" : "if";
              itemStart = itemStart + if_ + ("(" + discrim + "){");
              var code = byDiscriminant[discrim];
              if (typeof code === "string") {
                itemStart = itemStart + code + "}";
              } else {
                var caught$2 = "";
                for(var idx$4 = 0 ,idx_finish$2 = code.length; idx$4 < idx_finish$2; ++idx$4){
                  var code$1 = code[idx$4];
                  var errorVar$1 = "e" + idx$4;
                  itemStart = itemStart + ("try{" + code$1 + "}catch(" + errorVar$1 + "){");
                  caught$2 = caught$2 + "," + errorVar$1;
                }
                itemStart = itemStart + fail(caught$2) + "}".repeat(code.length) + "}";
              }
              itemNextElse = true;
            }
            byDiscriminant = {};
          }
          if (!itemCond) {
            if (itemCode$1) {
              if (itemNoop) {
                var if_$1 = itemNextElse ? "else if" : "if";
                itemStart = itemStart + if_$1 + ("(!(" + itemNoop + ")){");
                itemEnd = "}" + itemEnd;
                itemNoop = "";
                itemNextElse = false;
              }
              var errorVar$2 = "e" + itemIdx;
              itemStart = itemStart + ((
                  itemNextElse ? "else{" : ""
                ) + "try{" + itemCode$1 + "}catch(" + errorVar$2 + "){");
              itemEnd = (
                itemNextElse ? "}" : ""
              ) + "}" + itemEnd;
              caught$1 = caught$1 + "," + errorVar$2;
              itemNextElse = false;
            } else {
              itemNoop = "";
              itemIdx = lastIdx$1;
            }
          }
          itemIdx = itemIdx + 1;
        }        cond = validation(b, inputVar, {
              type: firstSchema.type,
              builder: 0
            }, false);
        if (itemNoop) {
          if (itemStart) {
            if (typeValidation) {
              var if_$2 = itemNextElse ? "else if" : "if";
              itemStart = itemStart + if_$2 + ("(!(" + itemNoop + ")){" + fail(caught$1) + "}");
            }
            
          } else {
            cond = cond + ("&&(" + itemNoop + ")");
          }
        } else if (typeValidation && itemStart) {
          var errorCode = fail(caught$1);
          itemStart = itemStart + (
            itemNextElse ? "else{" + errorCode + "}" : errorCode
          );
        }
        body = itemStart + itemEnd;
      } else {
        cond = validation(b, inputVar, firstSchema, false) + refinement(b, inputVar, firstSchema, false);
        body = getItemCode(b, firstSchema, input, input, false, path);
      }
      var cond$1 = cond;
      if (body || isPriority(firstSchema.type, byKey$1)) {
        var if_$3 = nextElse ? "else if" : "if";
        start = start + if_$3 + ("(" + cond$1 + "){" + body + "}");
        nextElse = true;
      } else {
        noop = noop ? noop + "||" + cond$1 : cond$1;
      }
    }
    if (typeValidation || deoptIdx$1 === lastIdx) {
      var errorCode$1 = fail(caught);
      var tmp;
      if (noop) {
        var if_$4 = nextElse ? "else if" : "if";
        tmp = if_$4 + ("(!(" + noop + ")){" + errorCode$1 + "}");
      } else {
        tmp = nextElse ? "else{" + errorCode$1 + "}" : errorCode$1;
      }
      start = start + tmp;
    }
    
  }
  b.c = b.c + start + end;
  if (input.a) {
    return {
            b: b,
            v: _notVar,
            i: "Promise.resolve(" + input.i + ")",
            a: true
          };
  } else if (input.v === _var) {
    if (b.c === "" && input.b.c === "" && (input.b.l === input.i + "=" + initialInline || initialInline === "i")) {
      input.b.l = "";
      input.b.a = initialAllocate;
      input.v = _notVar;
      input.i = initialInline;
      return input;
    } else {
      return {
              b: input.b,
              v: input.v,
              i: input.i,
              a: input.a
            };
    }
  } else {
    return input;
  }
}

function factory(schemas) {
  var len = schemas.length;
  if (len === 1) {
    return schemas[0];
  }
  if (len !== 0) {
    var has = {};
    var anyOf = new Set();
    for(var idx = 0 ,idx_finish = schemas.length; idx < idx_finish; ++idx){
      var schema = schemas[idx];
      if (schema.type === "union" && schema.builder === builder$1) {
        schema.anyOf.forEach(function (item) {
              anyOf.add(item);
            });
        Object.assign(has, schema.has);
      } else {
        anyOf.add(schema);
        var v = schema.type;
        var tmp;
        switch (v) {
          case "union" :
          case "json" :
              tmp = "unknown";
              break;
          default:
            tmp = v;
        }
        has[tmp] = true;
      }
    }
    var mut = new Schema$1();
    mut.type = "union";
    mut.anyOf = Array.from(anyOf);
    mut.builder = builder$1;
    mut.output = output$1;
    mut.has = has;
    return mut;
  }
  throw new Error("[Sury] S.union requires at least one item");
}

function output$1() {
  var schemas = this.anyOf;
  var items = [];
  var toSelf = true;
  for(var idx = 0 ,idx_finish = schemas.length; idx < idx_finish; ++idx){
    var schema = schemas[idx];
    var reversed = reverse$1(schema);
    items[idx] = reversed;
    toSelf = toSelf && schema === reversed;
  }
  if (toSelf) {
    return this;
  } else {
    return factory(items);
  }
}

var defaultMetadataId = "m:Option.default";

function $$default(schema) {
  return schema[defaultMetadataId];
}

var nestedLoc = "BS_PRIVATE_NESTED_SOME_NONE";

var inLoc = "\"" + nestedLoc + "\"";

function nestedNone() {
  var item_schema = parse$1(0);
  var item = {
    schema: item_schema,
    location: nestedLoc,
    inlinedLocation: inLoc
  };
  var fields = {};
  fields[nestedLoc] = item;
  return {
          type: "object",
          builder: (function (b, param, selfSchema, param$1) {
              return {
                      b: b,
                      v: _notVar,
                      i: inlineConst(b, reverse$1(selfSchema)),
                      a: false
                    };
            }),
          additionalItems: "strip",
          items: [item],
          fields: fields
        };
}

function builder$2(b, param, selfSchema, param$1) {
  return {
          b: b,
          v: _notVar,
          i: "{" + inLoc + ":" + reverse$1(selfSchema).items[0].schema.const + "}",
          a: false
        };
}

function nestedOption(item) {
  var mut = copy(item);
  mut.output = nestedNone;
  mut.builder = builder$2;
  return mut;
}

function factory$1(item, unitOpt) {
  var unit = unitOpt !== undefined ? unitOpt : $$undefined;
  var reversed = reverse$1(item);
  var match = reversed.type;
  switch (match) {
    case "undefined" :
        return factory([
                    unit,
                    nestedOption(item)