482 lines
64 KiB
JavaScript
482 lines
64 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.partial = exports.Nested = exports.MergeIntersect = exports.deepPartial = exports.PartialStruct = exports.allowMissing = exports.optional = exports.exact = exports.subtype = exports.Struct = exports.allowsOptional = exports.allowsMissing = exports.keyType = exports.dict = exports.Dict = exports.OptionalKey = exports.MissingKey = void 0;
|
|
const result_1 = require("../result");
|
|
const type_1 = require("../type");
|
|
/*
|
|
* MissingKey is a marker type that indicates that the key in a struct that holds an MissingKey is
|
|
* optional. However, if the key is present, the value must typecheck T; it can't be left undefined.
|
|
* This can be useful for verification but it's not equivalent to TypeScript's optional fields,
|
|
* which can be left undefined even when present.
|
|
*/
|
|
class MissingKey {
|
|
constructor(type) {
|
|
this.type = type;
|
|
}
|
|
}
|
|
exports.MissingKey = MissingKey;
|
|
/*
|
|
* OptionalKey mimics TypeScript's ?: optional field syntax in types/interfaces: it allows the key
|
|
* to be missing, or set to undefined.
|
|
*/
|
|
class OptionalKey {
|
|
constructor(type) {
|
|
this.type = type;
|
|
}
|
|
}
|
|
exports.OptionalKey = OptionalKey;
|
|
class MergeableType extends type_1.CustomCommutativeAndType {
|
|
and(type) {
|
|
if (type instanceof MergeableType) {
|
|
// @ts-ignore
|
|
return new MergeIntersect(this, type);
|
|
}
|
|
else if (type instanceof type_1.Either) {
|
|
return new type_1.Either(this.and(type.l), this.and(type.r));
|
|
}
|
|
else if (type instanceof type_1.DefaultIntersect) {
|
|
return new type_1.DefaultIntersect(this.and(type.l), this.and(type.r));
|
|
}
|
|
else if (type instanceof type_1.Comment) {
|
|
return new type_1.Comment(type.commentStr, this.and(type.wrapped));
|
|
}
|
|
return super.and(type);
|
|
}
|
|
}
|
|
// Dicts and structs merge together in TypeScript, so we put both in the struct file
|
|
class Dict extends MergeableType {
|
|
constructor(v, namedKey = "key") {
|
|
super();
|
|
this.namedKey = namedKey;
|
|
this.valueType = v;
|
|
}
|
|
keyName(key) {
|
|
return new Dict(this.valueType, key);
|
|
}
|
|
check(val) {
|
|
const err = basicDictErrs(val);
|
|
if (err)
|
|
return err;
|
|
for (const prop in val) {
|
|
const result = this.valueType.check(val[prop]);
|
|
if (result instanceof result_1.Err)
|
|
return new result_1.Err(`[${prop}]: ${result.message}`);
|
|
}
|
|
return val;
|
|
}
|
|
sliceResult(val) {
|
|
const err = basicDictErrs(val);
|
|
if (err)
|
|
return err;
|
|
const result = {};
|
|
for (const prop in val) {
|
|
const sliced = this.valueType.sliceResult(val[prop]);
|
|
if (sliced instanceof result_1.Err)
|
|
return new result_1.Err(`[${prop}]: ${result.message}`);
|
|
result[prop] = sliced;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
exports.Dict = Dict;
|
|
function basicDictErrs(val) {
|
|
if (typeof val !== 'object')
|
|
return new result_1.Err(`${val} is not an object`);
|
|
if (Array.isArray(val))
|
|
return new result_1.Err(`${val} is an array`);
|
|
if (val === null)
|
|
return new result_1.Err(`${val} is null`);
|
|
return null;
|
|
}
|
|
function dict(v) {
|
|
return new Dict(v);
|
|
}
|
|
exports.dict = dict;
|
|
function keyType(box) {
|
|
if (box instanceof MissingKey || box instanceof OptionalKey) {
|
|
return box.type;
|
|
}
|
|
return box;
|
|
}
|
|
exports.keyType = keyType;
|
|
function allowsMissing(box) {
|
|
return (box instanceof MissingKey);
|
|
}
|
|
exports.allowsMissing = allowsMissing;
|
|
function allowsOptional(box) {
|
|
return (box instanceof OptionalKey);
|
|
}
|
|
exports.allowsOptional = allowsOptional;
|
|
class Struct extends MergeableType {
|
|
constructor(definition, exact) {
|
|
super();
|
|
this.definition = definition;
|
|
this.exact = exact;
|
|
}
|
|
check(val) {
|
|
const typeErr = this.checkType(val);
|
|
if (typeErr)
|
|
return typeErr;
|
|
const errs = this.checkFields(val, (t, val) => t.check(val));
|
|
if (errs.length === 0)
|
|
return val;
|
|
return new result_1.Err(`${val} failed the following checks:\n${errs.join('\n')}`);
|
|
}
|
|
sliceResult(val) {
|
|
const typeErr = this.checkType(val);
|
|
if (typeErr)
|
|
return typeErr;
|
|
const sliced = {};
|
|
const errs = this.checkFields(val, (t, val) => t.sliceResult(val), (key, val) => {
|
|
sliced[key] = val;
|
|
});
|
|
if (errs.length === 0)
|
|
return sliced;
|
|
return new result_1.Err(`${val} failed the following checks:\n${errs.join('\n')}`);
|
|
}
|
|
checkType(val) {
|
|
if (typeof val !== 'object')
|
|
return new result_1.Err(`${val} is not an object`);
|
|
if (Array.isArray(val))
|
|
return new result_1.Err(`${val} is an array`);
|
|
if (val === null)
|
|
return new result_1.Err(`${val} is null`);
|
|
return undefined;
|
|
}
|
|
checkFields(val, checkFn, collect) {
|
|
const errs = [];
|
|
for (const prop in this.definition) {
|
|
const field = this.definition[prop];
|
|
if (!(prop in val)) {
|
|
if (allowsMissing(field))
|
|
continue;
|
|
if (allowsOptional(field))
|
|
continue;
|
|
errs.push(`missing key '${prop}'`);
|
|
continue;
|
|
}
|
|
const valField = val[prop];
|
|
if (valField === undefined && allowsOptional(field)) {
|
|
if (collect)
|
|
collect(prop, undefined);
|
|
continue;
|
|
}
|
|
const result = checkFn(keyType(field), valField);
|
|
if (result instanceof result_1.Err)
|
|
errs.push(result.message);
|
|
if (collect)
|
|
collect(prop, result);
|
|
}
|
|
if (this.exact && typeof val === 'object') {
|
|
for (const prop in val) {
|
|
if (!(prop in this.definition)) {
|
|
errs.push(`unknown key ${prop}`);
|
|
}
|
|
}
|
|
}
|
|
return errs;
|
|
}
|
|
}
|
|
exports.Struct = Struct;
|
|
function subtype(def) {
|
|
return new Struct(def, false);
|
|
}
|
|
exports.subtype = subtype;
|
|
function exact(def) {
|
|
return new Struct(def, true);
|
|
}
|
|
exports.exact = exact;
|
|
function optional(check) {
|
|
return new OptionalKey(check);
|
|
}
|
|
exports.optional = optional;
|
|
function allowMissing(check) {
|
|
return new MissingKey(check);
|
|
}
|
|
exports.allowMissing = allowMissing;
|
|
class PartialStruct extends MergeableType {
|
|
constructor(struct) {
|
|
super();
|
|
this.struct = struct;
|
|
const partialDef = {};
|
|
for (const k in struct.definition) {
|
|
const v = struct.definition[k];
|
|
if (v instanceof MissingKey) {
|
|
//@ts-ignore
|
|
partialDef[k] = optional(v.type);
|
|
}
|
|
else if (v instanceof OptionalKey) {
|
|
//@ts-ignore
|
|
partialDef[k] = optional(v.type);
|
|
}
|
|
else {
|
|
//@ts-ignore
|
|
partialDef[k] = optional(v);
|
|
}
|
|
}
|
|
this.hiddenTypeStruct = partialDef;
|
|
this.hiddenStruct = new Struct(this.hiddenTypeStruct, struct.exact);
|
|
}
|
|
check(val) {
|
|
return this.hiddenStruct.check(val);
|
|
}
|
|
sliceResult(val) {
|
|
return this.hiddenStruct.sliceResult(val);
|
|
}
|
|
reify() {
|
|
return new Struct(this.hiddenTypeStruct, this.hiddenStruct.exact);
|
|
}
|
|
}
|
|
exports.PartialStruct = PartialStruct;
|
|
function deepPartial(ogstruct) {
|
|
// If the original struct isn't nested, it's just an ordinary partial call. Don't modify the
|
|
// definition, or else when you convert to TypeScript it won't correctly ref out the struct
|
|
if (!hasNested(ogstruct)) {
|
|
// @ts-ignore
|
|
return partial(ogstruct);
|
|
}
|
|
// If we got this far, the struct has nesting, and therefore can't simply be ref-ed out when
|
|
// converting to TypeScript. We must modify it recursively.
|
|
const partialDef = {};
|
|
for (const k in ogstruct.definition) {
|
|
const v = ogstruct.definition[k];
|
|
if (v instanceof MissingKey) {
|
|
//@ts-ignore
|
|
partialDef[k] = new MissingKey(v.type);
|
|
}
|
|
else if (v instanceof OptionalKey) {
|
|
//@ts-ignore
|
|
partialDef[k] = optional(v.type);
|
|
}
|
|
else {
|
|
const deepKind = deepPartialKind(v);
|
|
// @ts-ignore
|
|
partialDef[k] = deepKind;
|
|
}
|
|
}
|
|
const struct = new Struct(partialDef, ogstruct.exact);
|
|
return new PartialStruct(struct);
|
|
}
|
|
exports.deepPartial = deepPartial;
|
|
class MergeIntersect extends MergeableType {
|
|
constructor(l, r) {
|
|
super();
|
|
this.l = l;
|
|
this.r = r;
|
|
this.merged = merge(l, {
|
|
dict: l => this.mergeDictAndMergeable(l, r),
|
|
struct: l => this.mergeStructAndMergeable(l, r),
|
|
partial: l => this.mergeStructAndMergeable(l.reify(), r),
|
|
merge: l => this.mergeIntersectAndMergeable(l, r),
|
|
internal: () => {
|
|
throw `leaked internal dict/struct merge class; structural error`;
|
|
},
|
|
});
|
|
}
|
|
check(val) {
|
|
return this.merged.check(val);
|
|
}
|
|
sliceResult(val) {
|
|
return this.merged.sliceResult(val);
|
|
}
|
|
mergeDictAndMergeable(d, m) {
|
|
return merge(m, {
|
|
dict: (m) => this.mergeDicts(d, m),
|
|
partial: (m) => new InternalDictStructMerge(m.reify(), d),
|
|
struct: (m) => this.mergeDictAndStruct(d, m),
|
|
merge: (m) => this.mergeDictAndMergeable(d, m.merged),
|
|
internal: (m) => this.mergeInternalAndDict(m, d),
|
|
});
|
|
}
|
|
mergeStructAndMergeable(s, m) {
|
|
return merge(m, {
|
|
dict: m => this.mergeDictAndStruct(m, s),
|
|
partial: m => this.mergeStructs(s, m.reify()),
|
|
struct: m => this.mergeStructs(s, m),
|
|
merge: m => this.mergeStructAndMergeable(s, m.merged),
|
|
internal: m => this.mergeInternalAndStruct(m, s),
|
|
});
|
|
}
|
|
mergePartialAndMergeable(p, m) {
|
|
return merge(m, {
|
|
dict: m => new InternalDictStructMerge(p.reify(), m),
|
|
partial: m => this.mergeStructs(p.reify(), m.reify()),
|
|
struct: m => this.mergeStructs(p.reify(), m),
|
|
merge: m => this.mergePartialAndMergeable(p, m.merged),
|
|
internal: m => this.mergeInternalAndStruct(m, p.reify()),
|
|
});
|
|
}
|
|
mergeIntersectAndMergeable(i, m) {
|
|
return merge(m, {
|
|
dict: m => this.mergeDictAndMergeable(m, i.merged),
|
|
partial: m => this.mergePartialAndMergeable(m, i.merged),
|
|
struct: m => this.mergeStructAndMergeable(m, i.merged),
|
|
merge: m => this.mergeIntersectAndMergeable(m, i.merged),
|
|
internal: m => this.mergeInternalAndIntersect(m, i),
|
|
});
|
|
}
|
|
mergeInternalAndDict(l, r) {
|
|
return new InternalDictStructMerge(l.s, this.mergeDicts(l.d, r));
|
|
}
|
|
mergeInternalAndStruct(l, r) {
|
|
return new InternalDictStructMerge(this.mergeStructs(l.s, r), l.d);
|
|
}
|
|
mergeInternalAndIntersect(l, r) {
|
|
return merge(r.merged, {
|
|
dict: merged => this.mergeInternalAndDict(l, merged),
|
|
partial: merged => this.mergeInternalAndStruct(l, merged.reify()),
|
|
struct: merged => this.mergeInternalAndStruct(l, merged),
|
|
merge: () => {
|
|
throw `MergeIntersect can't be a child of a MergeIntersect; structural internal error`;
|
|
},
|
|
internal: merged => this.mergeInternalAndInternal(l, merged),
|
|
});
|
|
}
|
|
mergeInternalAndInternal(l, r) {
|
|
return new InternalDictStructMerge(this.mergeStructs(l.s, r.s), this.mergeDicts(l.d, r.d));
|
|
}
|
|
mergeDicts(l, r) {
|
|
return dict(l.valueType.and(r.valueType));
|
|
}
|
|
mergeDictAndStruct(l, r) {
|
|
return new InternalDictStructMerge(r, l);
|
|
}
|
|
mergeStructs(l, r) {
|
|
const definition = {};
|
|
for (const prop in l.definition) {
|
|
definition[prop] = l.definition[prop];
|
|
}
|
|
for (const prop in r.definition) {
|
|
const existing = definition[prop];
|
|
const merging = r.definition[prop];
|
|
// If it's an additional key, slap it in
|
|
if (existing == null)
|
|
definition[prop] = r.definition[prop];
|
|
// If it's a missing key, handle
|
|
else if (existing instanceof MissingKey) {
|
|
// Missing keys are stricter than optional, so both converge to missing key
|
|
if (merging instanceof MissingKey || merging instanceof OptionalKey) {
|
|
definition[prop] = new MissingKey(existing.type.and(merging.type));
|
|
}
|
|
// The strictest is just a raw type, so unwrap and merge
|
|
else {
|
|
definition[prop] = existing.type.and(merging);
|
|
}
|
|
}
|
|
// If it's an optional key, handle
|
|
else if (existing instanceof OptionalKey) {
|
|
// Missing key is stricter than optional, so it wins
|
|
if (merging instanceof MissingKey) {
|
|
definition[prop] = new MissingKey(existing.type.and(merging.type));
|
|
}
|
|
// Two optionals merge into an optional
|
|
else if (merging instanceof OptionalKey) {
|
|
definition[prop] = new OptionalKey(existing.type.and(merging.type));
|
|
}
|
|
// A raw type is stricter than optional, so it unwraps the optionality
|
|
else {
|
|
definition[prop] = existing.type.and(merging);
|
|
}
|
|
}
|
|
else {
|
|
// Raw types are stricter than missing or optional types
|
|
if (merging instanceof MissingKey || merging instanceof OptionalKey) {
|
|
definition[prop] = existing.and(merging.type);
|
|
}
|
|
// Finally, merging two raw types
|
|
else {
|
|
definition[prop] = existing.and(merging);
|
|
}
|
|
}
|
|
}
|
|
return new Struct(definition, l.exact && r.exact);
|
|
}
|
|
}
|
|
exports.MergeIntersect = MergeIntersect;
|
|
function merge(i, handlers) {
|
|
if (i instanceof Dict)
|
|
return handlers.dict(i);
|
|
if (i instanceof PartialStruct)
|
|
return handlers.partial(i);
|
|
if (i instanceof Struct)
|
|
return handlers.struct(i);
|
|
if (i instanceof MergeIntersect)
|
|
return handlers.merge(i);
|
|
if (i instanceof InternalDictStructMerge)
|
|
return handlers.internal(i);
|
|
throw `Unknown type ${i}`;
|
|
}
|
|
class InternalDictStructMerge extends type_1.Type {
|
|
constructor(s, d) {
|
|
super();
|
|
this.d = d;
|
|
this.s = new Struct(s.definition, false);
|
|
}
|
|
check(val) {
|
|
const dResult = this.d.check(val);
|
|
if (dResult instanceof result_1.Err)
|
|
return dResult;
|
|
const sResult = this.s.check(val);
|
|
if (sResult instanceof result_1.Err)
|
|
return sResult;
|
|
return val;
|
|
}
|
|
sliceResult(val) {
|
|
const dResult = this.d.sliceResult(val);
|
|
if (dResult instanceof result_1.Err)
|
|
return dResult;
|
|
const sResult = this.s.sliceResult(val);
|
|
return Object.assign({}, dResult, sResult);
|
|
}
|
|
}
|
|
exports.Nested = [
|
|
Struct,
|
|
PartialStruct,
|
|
Dict,
|
|
type_1.Either,
|
|
type_1.DefaultIntersect,
|
|
MergeIntersect,
|
|
type_1.Comment,
|
|
];
|
|
function deepPartialKind(kind) {
|
|
if (isNested(kind))
|
|
return handleNested(kind);
|
|
return kind;
|
|
}
|
|
function handleNested(kind) {
|
|
if (kind instanceof Struct) {
|
|
if (hasNested(kind))
|
|
return deepPartial(kind);
|
|
return new PartialStruct(kind);
|
|
}
|
|
if (kind instanceof PartialStruct)
|
|
return deepPartial(kind.struct);
|
|
if (kind instanceof type_1.Comment)
|
|
return new type_1.Comment(kind.commentStr, deepPartialKind(kind.wrapped));
|
|
if (kind instanceof Dict)
|
|
return new Dict(deepPartialKind(kind.valueType), kind.namedKey);
|
|
if (kind instanceof type_1.Either)
|
|
return new type_1.Either(deepPartialKind(kind.l), deepPartialKind(kind.r));
|
|
if (kind instanceof MergeIntersect)
|
|
return new type_1.DefaultIntersect(deepPartialKind(kind.l), deepPartialKind(kind.r));
|
|
return new type_1.DefaultIntersect(deepPartialKind(kind.l), deepPartialKind(kind.r));
|
|
}
|
|
function isNested(kind) {
|
|
for (const t of exports.Nested) {
|
|
if (kind instanceof t)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function hasNested(struct) {
|
|
for (const k in struct.definition) {
|
|
if (isNested(struct.definition[k]))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function partial(struct) {
|
|
return new PartialStruct(struct);
|
|
}
|
|
exports.partial = partial;
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"struct.js","sourceRoot":"","sources":["../../../lib/checks/struct.ts"],"names":[],"mappings":";;;AAAA,sCAAwC;AACxC,kCAA4F;AAG5F;;;;;GAKG;AACH,MAAa,UAAU;IACrB,YAAqB,IAAO;QAAP,SAAI,GAAJ,IAAI,CAAG;IAAG,CAAC;CACjC;AAFD,gCAEC;AAED;;;GAGG;AACH,MAAa,WAAW;IACtB,YAAqB,IAAO;QAAP,SAAI,GAAJ,IAAI,CAAG;IAAG,CAAC;CACjC;AAFD,kCAEC;AASD,MAAe,aAAiB,SAAQ,+BAA2B;IACjE,GAAG,CAAW,IAAoB;QAChC,IAAG,IAAI,YAAY,aAAa,EAAE,CAAC;YACjC,aAAa;YACb,OAAO,IAAI,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACxC,CAAC;aACI,IAAG,IAAI,YAAY,aAAM,EAAE,CAAC;YAC/B,OAAO,IAAI,aAAM,CACf,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAChB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CACjB,CAAC;QACJ,CAAC;aACI,IAAG,IAAI,YAAY,uBAAgB,EAAE,CAAC;YACzC,OAAO,IAAI,uBAAgB,CACzB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAChB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CACjB,CAAC;QACJ,CAAC;aACI,IAAG,IAAI,YAAY,cAAO,EAAE,CAAC;YAChC,OAAO,IAAI,cAAO,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;CACF;AAED,oFAAoF;AACpF,MAAa,IAAQ,SAAQ,aAAyB;IAEpD,YAAY,CAAU,EAAW,WAAmB,KAAK;QACvD,KAAK,EAAE,CAAC;QADuB,aAAQ,GAAR,QAAQ,CAAgB;QAEvD,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;IACrB,CAAC;IAED,OAAO,CAAC,GAAW;QACjB,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IACvC,CAAC;IAED,KAAK,CAAC,GAAQ;QACZ,MAAM,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAG,GAAG;YAAE,OAAO,GAAG,CAAC;QAEnB,KAAI,MAAM,IAAI,IAAI,GAAG,EAAE,CAAC;YACtB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;YAC/C,IAAG,MAAM,YAAY,YAAG;gBAAE,OAAO,IAAI,YAAG,CAAC,IAAI,IAAI,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;QAC3E,CAAC;QAED,OAAO,GAAyB,CAAC;IACnC,CAAC;IAED,WAAW,CAAC,GAAQ;QAClB,MAAM,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAG,GAAG;YAAE,OAAO,GAAG,CAAC;QAEnB,MAAM,MAAM,GAA2B,EAAE,CAAC;QAC1C,KAAI,MAAM,IAAI,IAAI,GAAG,EAAE,CAAC;YACtB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;YACrD,IAAG,MAAM,YAAY,YAAG;gBAAE,OAAO,IAAI,YAAG,CAAC,IAAI,IAAI,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;YACzE,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;QACxB,CAAC;QAED,OAAO,MAA4B,CAAC;IACtC,CAAC;CACF;AApCD,oBAoCC;AAED,SAAS,aAAa,CAAI,GAAQ;IAChC,IAAG,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,IAAI,YAAG,CAAC,GAAG,GAAG,mBAAmB,CAAC,CAAC;IACtE,IAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,YAAG,CAAC,GAAG,GAAG,cAAc,CAAC,CAAC;IAC5D,IAAG,GAAG,KAAK,IAAI;QAAE,OAAO,IAAI,YAAG,CAAC,GAAG,GAAG,UAAU,CAAC,CAAC;IAClD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAgB,IAAI,CAAI,CAAU;IAChC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;AACrB,CAAC;AAFD,oBAEC;AA+BD,SAAgB,OAAO,CAAI,GAAyD;IAClF,IAAG,GAAG,YAAY,UAAU,IAAI,GAAG,YAAY,WAAW,EAAE,CAAC;QAC3D,OAAO,GAAG,CAAC,IAAI,CAAC;IAClB,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAND,0BAMC;AAED,SAAgB,aAAa,CAAsB,GAAsB;IACvE,OAAO,CAAC,GAAG,YAAY,UAAU,CAAC,CAAC;AACrC,CAAC;AAFD,sCAEC;AAED,SAAgB,cAAc,CAAsB,GAAsB;IACxE,OAAO,CAAC,GAAG,YAAY,WAAW,CAAC,CAAC;AACtC,CAAC;AAFD,wCAEC;AAED,MAAa,MAA6B,SAAQ,aAAqC;IAIrF,YAAY,UAAa,EAAE,KAAc;QACvC,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,KAAK,CAAC,GAAQ;QACZ,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QACpC,IAAG,OAAO;YAAE,OAAO,OAAO,CAAC;QAE3B,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;QAE7D,IAAG,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,GAA6B,CAAC;QAC3D,OAAO,IAAI,YAAG,CAAC,GAAG,GAAG,kCAAkC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5E,CAAC;IAED,WAAW,CAAC,GAAQ;QAClB,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QACpC,IAAG,OAAO;YAAE,OAAO,OAAO,CAAC;QAC3B,MAAM,MAAM,GAA2B,EAAE,CAAC;QAE1C,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YAC9E,MAAM,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;QACpB,CAAC,CAAC,CAAC;QAEH,IAAG,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,MAAgC,CAAC;QAC9D,OAAO,IAAI,YAAG,CAAC,GAAG,GAAG,kCAAkC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5E,CAAC;IAEO,SAAS,CAAC,GAAQ;QACxB,IAAG,OAAO,GAAG,KAAK,QAAQ;YAAE,OAAO,IAAI,YAAG,CAAC,GAAG,GAAG,mBAAmB,CAAC,CAAC;QACtE,IAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;YAAE,OAAO,IAAI,YAAG,CAAC,GAAG,GAAG,cAAc,CAAC,CAAC;QAC5D,IAAG,GAAG,KAAK,IAAI;YAAE,OAAO,IAAI,YAAG,CAAC,GAAG,GAAG,UAAU,CAAC,CAAC;QAClD,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,WAAW,CAAC,GAAQ,EAAE,OAAgD,EAAE,OAAwC;QACtH,MAAM,IAAI,GAAa,EAAE,CAAC;QAC1B,KAAI,MAAM,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClC,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;YACnC,IAAG,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;gBAClB,IAAG,aAAa,CAAC,KAAK,CAAC;oBAAE,SAAS;gBAClC,IAAG,cAAc,CAAC,KAAK,CAAC;oBAAE,SAAS;gBAEnC,IAAI,CAAC,IAAI,CAAC,gBAAgB,IAAI,GAAG,CAAC,CAAC;gBACnC,SAAS;YACX,CAAC;YAED,MAAM,QAAQ,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;YAC3B,IAAG,QAAQ,KAAK,SAAS,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;gBACnD,IAAG,OAAO;oBAAE,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;gBACrC,SAAS;YACX,CAAC;YAED,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC;YACjD,IAAG,MAAM,YAAY,YAAG;gBAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACpD,IAAG,OAAO;gBAAE,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACpC,CAAC;QAED,IAAG,IAAI,CAAC,KAAK,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YACzC,KAAI,MAAM,IAAI,IAAI,GAAG,EAAE,CAAC;gBACtB,IAAG,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;oBAC9B,IAAI,CAAC,IAAI,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC;gBACnC,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAzED,wBAyEC;AAED,SAAgB,OAAO,CAAuB,GAAM;IAClD,OAAO,IAAI,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AAChC,CAAC;AAFD,0BAEC;AAED,SAAgB,KAAK,CAAuB,GAAM;IAChD,OAAO,IAAI,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AAC/B,CAAC;AAFD,sBAEC;AAED,SAAgB,QAAQ,CAAsB,KAAQ;IACpD,OAAO,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC;AAFD,4BAEC;AAED,SAAgB,YAAY,CAAsB,KAAQ;IACxD,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAFD,oCAEC;AAcD,MAAa,aAAoC,SAAQ,aAAwD;IAG/G,YAAqB,MAAiB;QACpC,KAAK,EAAE,CAAC;QADW,WAAM,GAAN,MAAM,CAAW;QAEpC,MAAM,UAAU,GAAkC,EAAE,CAAC;QACrD,KAAI,MAAM,CAAC,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;YACjC,MAAM,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC/B,IAAG,CAAC,YAAY,UAAU,EAAE,CAAC;gBAC3B,YAAY;gBACZ,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACnC,CAAC;iBACI,IAAG,CAAC,YAAY,WAAW,EAAE,CAAC;gBACjC,YAAY;gBACZ,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACnC,CAAC;iBACI,CAAC;gBACJ,YAAY;gBACZ,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;YAC9B,CAAC;QACH,CAAC;QACD,IAAI,CAAC,gBAAgB,GAAG,UAAkC,CAAC;QAC3D,IAAI,CAAC,YAAY,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACtE,CAAC;IACD,KAAK,CAAC,GAAQ;QACZ,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACtC,CAAC;IACD,WAAW,CAAC,GAAQ;QAClB,OAAO,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK;QACH,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IACpE,CAAC;CACF;AAlCD,sCAkCC;AAGD,SAAgB,WAAW,CAAuB,QAAmB;IACnE,4FAA4F;IAC5F,2FAA2F;IAC3F,IAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxB,aAAa;QACb,OAAO,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC3B,CAAC;IAED,4FAA4F;IAC5F,2DAA2D;IAC3D,MAAM,UAAU,GAAsC,EAAE,CAAC;IACzD,KAAI,MAAM,CAAC,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;QACnC,MAAM,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QACjC,IAAG,CAAC,YAAY,UAAU,EAAE,CAAC;YAC3B,YAAY;YACZ,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACzC,CAAC;aACI,IAAG,CAAC,YAAY,WAAW,EAAE,CAAC;YACjC,YAAY;YACZ,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACnC,CAAC;aACI,CAAC;YACJ,MAAM,QAAQ,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;YACpC,aAAa;YACb,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC;QAC3B,CAAC;IACH,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,UAAsC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClF,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC;AA7BD,kCA6BC;AAED,MAAa,cAIX,SAAQ,aAA0B;IASlC,YAAqB,CAAI,EAAW,CAAI;QACtC,KAAK,EAAE,CAAC;QADW,MAAC,GAAD,CAAC,CAAG;QAAW,MAAC,GAAD,CAAC,CAAG;QAGtC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,EAAE;YACrB,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC;YAC3C,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC;YAC/C,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACxD,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC;YACjD,QAAQ,EAAE,GAAG,EAAE;gBACb,MAAM,2DAA2D,CAAC;YACpE,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,GAAQ;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC;IAED,WAAW,CAAC,GAAQ;QAClB,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACtC,CAAC;IAEO,qBAAqB,CAC3B,CAAY,EACZ,CAAmE;QAEnE,OAAO,KAAK,CAAC,CAAC,EAAE;YACd,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC;YAClC,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,uBAAuB,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACzD,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC;YAC5C,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC;YACrD,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC;SACjD,CAAC,CAAC;IACL,CAAC;IAEO,uBAAuB,CAC7B,CAAc,EACd,CAAmE;QAEnE,OAAO,KAAK,CAAC,CAAC,EAAE;YACd,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC;YACxC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;YAC7C,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;YACpC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC;YACrD,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC;SACjD,CAAC,CAAC;IACL,CAAC;IAEO,wBAAwB,CAC9B,CAAqB,EACrB,CAAmE;QAEnE,OAAO,KAAK,CAAC,CAAC,EAAE;YACd,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,uBAAuB,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACpD,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;YACrD,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YAC5C,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC;YACtD,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;SACzD,CAAC,CAAC;IACL,CAAC;IAEO,0BAA0B,CAChC,CAAqC,EACrC,CAAmE;QAEnE,OAAO,KAAK,CAAC,CAAC,EAAE;YACd,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC;YAClD,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC;YACxD,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC;YACtD,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC;YACxD,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC;SACpD,CAAC,CAAC;IACL,CAAC;IAEO,oBAAoB,CAAC,CAA8C,EAAE,CAAY;QACvF,OAAO,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACnE,CAAC;IAEO,sBAAsB,CAAC,CAA8C,EAAE,CAAc;QAC3F,OAAO,IAAI,uBAAuB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACrE,CAAC;IAEO,yBAAyB,CAC/B,CAA8C,EAC9C,CAAqC;QAErC,OAAO,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE;YACrB,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,EAAE,MAAM,CAAC;YACpD,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;YACjE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC,EAAE,MAAM,CAAC;YACxD,KAAK,EAAE,GAAG,EAAE;gBACV,MAAM,gFAAgF,CAAA;YACxF,CAAC;YACD,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC;SAC7D,CAAC,CAAC;IACL,CAAC;IAEO,wBAAwB,CAC9B,CAA8C,EAC9C,CAA8C;QAE9C,OAAO,IAAI,uBAAuB,CAChC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAC3B,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAC1B,CAAA;IACH,CAAC;IAEO,UAAU,CAAC,CAAU,EAAE,CAAU;QACvC,OAAO,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;IAC5C,CAAC;IAEO,kBAAkB,CAAC,CAAU,EAAE,CAAe;QACpD,OAAO,IAAI,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C,CAAC;IAEO,YAAY,CAAC,CAAc,EAAE,CAAc;QACjD,MAAM,UAAU,GAAgC,EAAE,CAAC;QAEnD,KAAI,MAAM,IAAI,IAAI,CAAC,CAAC,UAAU,EAAE,CAAC;YAC/B,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACxC,CAAC;QACD,KAAI,MAAM,IAAI,IAAI,CAAC,CAAC,UAAU,EAAE,CAAC;YAC/B,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;YAClC,MAAM,OAAO,GAAG,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACnC,wCAAwC;YACxC,IAAG,QAAQ,IAAI,IAAI;gBAAE,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAC3D,gCAAgC;iBAC3B,IAAG,QAAQ,YAAY,UAAU,EAAE,CAAC;gBACvC,2EAA2E;gBAC3E,IAAG,OAAO,YAAY,UAAU,IAAI,OAAO,YAAY,WAAW,EAAE,CAAC;oBACnE,UAAU,CAAC,IAAI,CAAC,GAAG,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;gBACrE,CAAC;gBACD,wDAAwD;qBACnD,CAAC;oBACJ,UAAU,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAChD,CAAC;YACH,CAAC;YACD,kCAAkC;iBAC7B,IAAG,QAAQ,YAAY,WAAW,EAAE,CAAC;gBACxC,oDAAoD;gBACpD,IAAG,OAAO,YAAY,UAAU,EAAE,CAAC;oBACjC,UAAU,CAAC,IAAI,CAAC,GAAG,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;gBACrE,CAAC;gBACD,uCAAuC;qBAClC,IAAG,OAAO,YAAY,WAAW,EAAE,CAAC;oBACvC,UAAU,CAAC,IAAI,CAAC,GAAG,IAAI,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;gBACtE,CAAC;gBACD,sEAAsE;qBACjE,CAAC;oBACJ,UAAU,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAChD,CAAC;YACH,CAAC;iBACI,CAAC;gBACJ,wDAAwD;gBACxD,IAAG,OAAO,YAAY,UAAU,IAAI,OAAO,YAAY,WAAW,EAAE,CAAC;oBACnE,UAAU,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBAChD,CAAC;gBACD,iCAAiC;qBAC5B,CAAC;oBACJ,UAAU,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAC3C,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC;IACpD,CAAC;CACF;AAnLD,wCAmLC;AAUD,SAAS,KAAK,CACZ,CAAQ,EACR,QAAuB;IAEvB,IAAG,CAAC,YAAY,IAAI;QAAE,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC9C,IAAG,CAAC,YAAY,aAAa;QAAE,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC1D,IAAG,CAAC,YAAY,MAAM;QAAE,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAClD,IAAG,CAAC,YAAY,cAAc;QAAE,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACzD,IAAG,CAAC,YAAY,uBAAuB;QAAE,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IACrE,MAAM,gBAAgB,CAAC,EAAE,CAAC;AAC5B,CAAC;AAED,MAAM,uBAIJ,SAAQ,WAA6B;IAErC,YAAY,CAAI,EAAW,CAAI;QAC7B,KAAK,EAAE,CAAC;QADiB,MAAC,GAAD,CAAC,CAAG;QAE7B,IAAI,CAAC,CAAC,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,UAAU,EAAE,KAAK,CAAM,CAAC;IAChD,CAAC;IAED,KAAK,CAAC,GAAQ;QACZ,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAClC,IAAG,OAAO,YAAY,YAAG;YAAE,OAAO,OAAO,CAAC;QAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAClC,IAAG,OAAO,YAAY,YAAG;YAAE,OAAO,OAAO,CAAC;QAC1C,OAAO,GAAG,CAAC;IACb,CAAC;IAED,WAAW,CAAC,GAAQ;QAClB,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACxC,IAAG,OAAO,YAAY,YAAG;YAAE,OAAO,OAAO,CAAC;QAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACxC,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,OAAO,CAA4B,CAAC;IACxE,CAAC;CACF;AAEY,QAAA,MAAM,GAAG;IACpB,MAAM;IACN,aAAa;IACb,IAAI;IACJ,aAAM;IACN,uBAAgB;IAChB,cAAc;IACd,cAAO;CACC,CAAC;AAGX,SAAS,eAAe,CAAC,IAAe;IACtC,IAAG,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC;IAC7C,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,YAAY,CAAC,IAAgB;IACpC,IAAG,IAAI,YAAY,MAAM,EAAE,CAAC;QAC1B,IAAG,SAAS,CAAC,IAAI,CAAC;YAAE,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC;QAC7C,OAAO,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IACD,IAAG,IAAI,YAAY,aAAa;QAAE,OAAO,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAClE,IAAG,IAAI,YAAY,cAAO;QAAE,OAAO,IAAI,cAAO,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/F,IAAG,IAAI,YAAY,IAAI;QAAE,OAAO,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACzF,IAAG,IAAI,YAAY,aAAM;QAAE,OAAO,IAAI,aAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/F,IAAG,IAAI,YAAY,cAAc;QAAE,OAAO,IAAI,uBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACjH,OAAO,IAAI,uBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AAChF,CAAC;AAED,SAAS,QAAQ,CAAC,IAA4B;IAC5C,KAAI,MAAM,CAAC,IAAI,cAAM,EAAE,CAAC;QACtB,IAAG,IAAI,YAAY,CAAC;YAAE,OAAO,IAAI,CAAC;IACpC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,SAAS,CAAC,MAAmB;IACpC,KAAI,MAAM,CAAC,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;QACjC,IAAG,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;IACjD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAgB,OAAO,CAAuB,MAAiB;IAC7D,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC;AAFD,0BAEC","sourcesContent":["import { Err, Result } from \"../result\";\nimport { Type, CustomCommutativeAndType, Either, DefaultIntersect, Comment } from \"../type\";\nimport { GetType } from \"../get-type\";\n\n/*\n * MissingKey is a marker type that indicates that the key in a struct that holds an MissingKey is\n * optional. However, if the key is present, the value must typecheck T; it can't be left undefined.\n * This can be useful for verification but it's not equivalent to TypeScript's optional fields,\n * which can be left undefined even when present.\n */\nexport class MissingKey<T extends Type<any>> {\n  constructor(readonly type: T) {}\n}\n\n/*\n * OptionalKey mimics TypeScript's ?: optional field syntax in types/interfaces: it allows the key\n * to be missing, or set to undefined.\n */\nexport class OptionalKey<T extends Type<any>> {\n  constructor(readonly type: T) {}\n}\n\ntype WrapperOrType<T> = T extends MissingKey<infer Inner> ? Inner :\n  T extends OptionalKey<infer Inner> ? Inner : T;\n\ntype RawDict<V> = {\n  [key: string]: V;\n};\n\nabstract class MergeableType<T> extends CustomCommutativeAndType<T> {\n  and<Incoming>(type: Type<Incoming>): Type<T & Incoming> {\n    if(type instanceof MergeableType) {\n      // @ts-ignore\n      return new MergeIntersect(this, type);\n    }\n    else if(type instanceof Either) {\n      return new Either(\n        this.and(type.l),\n        this.and(type.r),\n      );\n    }\n    else if(type instanceof DefaultIntersect) {\n      return new DefaultIntersect(\n        this.and(type.l),\n        this.and(type.r),\n      );\n    }\n    else if(type instanceof Comment) {\n      return new Comment(type.commentStr, this.and(type.wrapped));\n    }\n    return super.and(type);\n  }\n}\n\n// Dicts and structs merge together in TypeScript, so we put both in the struct file\nexport class Dict<V> extends MergeableType<RawDict<V>> {\n  readonly valueType: Type<V>;\n  constructor(v: Type<V>, readonly namedKey: string = \"key\") {\n    super();\n    this.valueType = v;\n  }\n\n  keyName(key: string): Dict<V> {\n    return new Dict(this.valueType, key);\n  }\n\n  check(val: any): Result<RawDict<V>> {\n    const err = basicDictErrs(val);\n    if(err) return err;\n\n    for(const prop in val) {\n      const result = this.valueType.check(val[prop]);\n      if(result instanceof Err) return new Err(`[${prop}]: ${result.message}`);\n    }\n\n    return val as Result<RawDict<V>>;\n  }\n\n  sliceResult(val: any): Result<RawDict<V>> {\n    const err = basicDictErrs(val);\n    if(err) return err;\n\n    const result: { [key: string]: any } = {};\n    for(const prop in val) {\n      const sliced = this.valueType.sliceResult(val[prop]);\n      if(sliced instanceof Err) return new Err(`[${prop}]: ${result.message}`);\n      result[prop] = sliced;\n    }\n\n    return result as Result<RawDict<V>>;\n  }\n}\n\nfunction basicDictErrs<V>(val: any): Err<V> | null {\n  if(typeof val !== 'object') return new Err(`${val} is not an object`);\n  if(Array.isArray(val)) return new Err(`${val} is an array`);\n  if(val === null) return new Err(`${val} is null`);\n  return null;\n}\n\nexport function dict<V>(v: Type<V>): Dict<V> {\n  return new Dict(v);\n}\n\nexport type FieldDef = Type<any> | MissingKey<any> | OptionalKey<any>;\n\nexport type TypeStruct = {\n  [key: string]: FieldDef\n};\n\n// see this blog post for an explanation of this type shenanigans\n// https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html\n\n// Returns a type like `\"foo\" | \"bar\"` for all the optional keys in a typestruct\ntype OptionalPropertyNames<T extends TypeStruct> = {\n  [K in keyof T]: T[K] extends MissingKey<any> ? K : T[K] extends OptionalKey<any> ? K : never;\n}[keyof T];\n\n// Unwraps Type<T> and OptionalKey<Type<T>> to T for all keys in a typestruct\ntype UnwrapTypes<T extends TypeStruct> = {\n  [K in keyof T]: GetType<WrapperOrType<T[K]>>;\n};\n\nexport type UnwrappedTypeStruct<T extends TypeStruct> =\n  /* required props */ Pick<UnwrapTypes<T>, Exclude<keyof T, OptionalPropertyNames<T>>> &\n  /* optional props */ Partial<Pick<UnwrapTypes<T>, OptionalPropertyNames<T>>>;\n\nexport type TypeStructFor<T> = {\n  [K in keyof T]: Type<T[K]>;\n};\n\nexport type StructFor<T> = Struct<TypeStructFor<T>>;\n\nexport function keyType<T>(box: MissingKey<Type<T>> | OptionalKey<Type<T>> | Type<T>): Type<T> {\n  if(box instanceof MissingKey || box instanceof OptionalKey) {\n    return box.type;\n  }\n\n  return box;\n}\n\nexport function allowsMissing<T extends Type<any>>(box: MissingKey<T> | T): box is MissingKey<T> {\n  return (box instanceof MissingKey);\n}\n\nexport function allowsOptional<T extends Type<any>>(box: MissingKey<T> | T): box is OptionalKey<T> {\n  return (box instanceof OptionalKey);\n}\n\nexport class Struct<T extends TypeStruct> extends MergeableType<UnwrappedTypeStruct<T>> {\n  readonly definition: T;\n  readonly exact: boolean;\n\n  constructor(definition: T, exact: boolean) {\n    super();\n    this.definition = definition;\n    this.exact = exact;\n  }\n\n  check(val: any): Result<UnwrappedTypeStruct<T>> {\n    const typeErr = this.checkType(val);\n    if(typeErr) return typeErr;\n\n    const errs = this.checkFields(val, (t, val) => t.check(val));\n\n    if(errs.length === 0) return val as UnwrappedTypeStruct<T>;\n    return new Err(`${val} failed the following checks:\\n${errs.join('\\n')}`);\n  }\n\n  sliceResult(val: any): Result<UnwrappedTypeStruct<T>> {\n    const typeErr = this.checkType(val);\n    if(typeErr) return typeErr;\n    const sliced: { [key: string]: any } = {};\n\n    const errs = this.checkFields(val, (t, val) => t.sliceResult(val), (key, val) => {\n      sliced[key] = val;\n    });\n\n    if(errs.length === 0) return sliced as UnwrappedTypeStruct<T>;\n    return new Err(`${val} failed the following checks:\\n${errs.join('\\n')}`);\n  }\n\n  private checkType(val: any): Err<UnwrappedTypeStruct<T>> | undefined {\n    if(typeof val !== 'object') return new Err(`${val} is not an object`);\n    if(Array.isArray(val)) return new Err(`${val} is an array`);\n    if(val === null) return new Err(`${val} is null`);\n    return undefined;\n  }\n\n  private checkFields(val: any, checkFn: (t: Type<any>, val: any) => Result<any>, collect?: (key: string, val: any) => any): string[] {\n    const errs: string[] = [];\n    for(const prop in this.definition) {\n      const field = this.definition[prop]\n      if(!(prop in val)) {\n        if(allowsMissing(field)) continue;\n        if(allowsOptional(field)) continue;\n\n        errs.push(`missing key '${prop}'`);\n        continue;\n      }\n\n      const valField = val[prop];\n      if(valField === undefined && allowsOptional(field)) {\n        if(collect) collect(prop, undefined);\n        continue;\n      }\n\n      const result = checkFn(keyType(field), valField);\n      if(result instanceof Err) errs.push(result.message);\n      if(collect) collect(prop, result);\n    }\n\n    if(this.exact && typeof val === 'object') {\n      for(const prop in val) {\n        if(!(prop in this.definition)) {\n          errs.push(`unknown key ${prop}`);\n        }\n      }\n    }\n\n    return errs;\n  }\n}\n\nexport function subtype<T extends TypeStruct>(def: T): Struct<T> {\n  return new Struct(def, false);\n}\n\nexport function exact<T extends TypeStruct>(def: T): Struct<T> {\n  return new Struct(def, true);\n}\n\nexport function optional<T extends Type<any>>(check: T): OptionalKey<T> {\n  return new OptionalKey(check);\n}\n\nexport function allowMissing<T extends Type<any>>(check: T): MissingKey<T> {\n  return new MissingKey(check);\n}\n\ntype MakeOptional<T extends FieldDef> = T extends Type<any> ? OptionalKey<T> :\n  T extends MissingKey<infer K> ? OptionalKey<K> : T;\n\ntype DeepPartialTypeStruct<T extends TypeStruct> = {\n  [K in keyof T]: T[K] extends Struct<infer T2> ? OptionalKey<Struct<DeepPartialTypeStruct<T2>>> :\n    MakeOptional<T[K]>\n}\n\ntype PartialTypeStruct<T extends TypeStruct> = {\n  [K in keyof T]: MakeOptional<T[K]>\n};\n\nexport class PartialStruct<T extends TypeStruct> extends MergeableType<UnwrappedTypeStruct<PartialTypeStruct<T>>> {\n  private readonly hiddenStruct: Struct<PartialTypeStruct<T>>;\n  private readonly hiddenTypeStruct: PartialTypeStruct<T>;\n  constructor(readonly struct: Struct<T>) {\n    super();\n    const partialDef: Partial<PartialTypeStruct<T>> = {};\n    for(const k in struct.definition) {\n      const v = struct.definition[k];\n      if(v instanceof MissingKey) {\n        //@ts-ignore\n        partialDef[k] = optional(v.type);\n      }\n      else if(v instanceof OptionalKey) {\n        //@ts-ignore\n        partialDef[k] = optional(v.type);\n      }\n      else {\n        //@ts-ignore\n        partialDef[k] = optional(v);\n      }\n    }\n    this.hiddenTypeStruct = partialDef as PartialTypeStruct<T>;\n    this.hiddenStruct = new Struct(this.hiddenTypeStruct, struct.exact);\n  }\n  check(val: any): Result<UnwrappedTypeStruct<PartialTypeStruct<T>>> {\n    return this.hiddenStruct.check(val);\n  }\n  sliceResult(val: any): Result<UnwrappedTypeStruct<PartialTypeStruct<T>>> {\n    return this.hiddenStruct.sliceResult(val);\n  }\n\n  reify(): Struct<PartialTypeStruct<T>> {\n    return new Struct(this.hiddenTypeStruct, this.hiddenStruct.exact);\n  }\n}\n\n\nexport function deepPartial<T extends TypeStruct>(ogstruct: Struct<T>): PartialStruct<DeepPartialTypeStruct<T>> {\n  // If the original struct isn't nested, it's just an ordinary partial call. Don't modify the\n  // definition, or else when you convert to TypeScript it won't correctly ref out the struct\n  if(!hasNested(ogstruct)) {\n    // @ts-ignore\n    return partial(ogstruct);\n  }\n\n  // If we got this far, the struct has nesting, and therefore can't simply be ref-ed out when\n  // converting to TypeScript. We must modify it recursively.\n  const partialDef: Partial<DeepPartialTypeStruct<T>> = {};\n  for(const k in ogstruct.definition) {\n    const v = ogstruct.definition[k];\n    if(v instanceof MissingKey) {\n      //@ts-ignore\n      partialDef[k] = new MissingKey(v.type);\n    }\n    else if(v instanceof OptionalKey) {\n      //@ts-ignore\n      partialDef[k] = optional(v.type);\n    }\n    else {\n      const deepKind = deepPartialKind(v);\n      // @ts-ignore\n      partialDef[k] = deepKind;\n    }\n  }\n  const struct = new Struct(partialDef as DeepPartialTypeStruct<T>, ogstruct.exact);\n  return new PartialStruct(struct);\n}\n\nexport class MergeIntersect<\n  LVal, RVal,\n  L extends MergeableType<LVal>,\n  R extends MergeableType<RVal>,\n> extends MergeableType<LVal & RVal> {\n\n  // DANGER: NEVER EVER LEAK THIS OBJECT\n  // This is for internal use only. Do not use its .and function. Do not pass it to other .and or\n  // .or functions. Do not use it AT ALL except to call .check or .sliceResult on it. It MAY be a\n  // secret internal class called InternalDictStructMerge (defined below) that does not play well\n  // with other types or type algebra.\n  protected readonly merged: Type<LVal & RVal>;\n\n  constructor(readonly l: L, readonly r: R) {\n    super();\n\n    this.merged = merge(l, {\n      dict: l => this.mergeDictAndMergeable(l, r),\n      struct: l => this.mergeStructAndMergeable(l, r),\n      partial: l => this.mergeStructAndMergeable(l.reify(), r),\n      merge: l => this.mergeIntersectAndMergeable(l, r),\n      internal: () => {\n        throw `leaked internal dict/struct merge class; structural error`;\n      },\n    });\n  }\n\n  check(val: any) {\n    return this.merged.check(val);\n  }\n\n  sliceResult(val: any) {\n    return this.merged.sliceResult(val);\n  }\n\n  private mergeDictAndMergeable(\n    d: Dict<any>,\n    m: MergeableType<any> | InternalDictStructMerge<any, any, any, any>\n  ): MergeableType<any> | InternalDictStructMerge<any, any, any, any> {\n    return merge(m, {\n      dict: (m) => this.mergeDicts(d, m),\n      partial: (m) => new InternalDictStructMerge(m.reify(), d),\n      struct: (m) => this.mergeDictAndStruct(d, m),\n      merge: (m) => this.mergeDictAndMergeable(d, m.merged),\n      internal: (m) => this.mergeInternalAndDict(m, d),\n    });\n  }\n\n  private mergeStructAndMergeable(\n    s: Struct<any>,\n    m: MergeableType<any> | InternalDictStructMerge<any, any, any, any>\n  ): MergeableType<any> | InternalDictStructMerge<any, any, any, any> {\n    return merge(m, {\n      dict: m => this.mergeDictAndStruct(m, s),\n      partial: m => this.mergeStructs(s, m.reify()),\n      struct: m => this.mergeStructs(s, m),\n      merge: m => this.mergeStructAndMergeable(s, m.merged),\n      internal: m => this.mergeInternalAndStruct(m, s),\n    });\n  }\n\n  private mergePartialAndMergeable(\n    p: PartialStruct<any>,\n    m: MergeableType<any> | InternalDictStructMerge<any, any, any, any>,\n  ): MergeableType<any> | InternalDictStructMerge<any, any, any, any> {\n    return merge(m, {\n      dict: m => new InternalDictStructMerge(p.reify(), m),\n      partial: m => this.mergeStructs(p.reify(), m.reify()),\n      struct: m => this.mergeStructs(p.reify(), m),\n      merge: m => this.mergePartialAndMergeable(p, m.merged),\n      internal: m => this.mergeInternalAndStruct(m, p.reify()),\n    });\n  }\n\n  private mergeIntersectAndMergeable(\n    i: MergeIntersect<any, any, any, any>,\n    m: MergeableType<any> | InternalDictStructMerge<any, any, any, any>\n  ): MergeableType<any> | InternalDictStructMerge<any, any, any, any> {\n    return merge(m, {\n      dict: m => this.mergeDictAndMergeable(m, i.merged),\n      partial: m => this.mergePartialAndMergeable(m, i.merged),\n      struct: m => this.mergeStructAndMergeable(m, i.merged),\n      merge: m => this.mergeIntersectAndMergeable(m, i.merged),\n      internal: m => this.mergeInternalAndIntersect(m, i),\n    });\n  }\n\n  private mergeInternalAndDict(l: InternalDictStructMerge<any, any, any, any>, r: Dict<any>) {\n    return new InternalDictStructMerge(l.s, this.mergeDicts(l.d, r));\n  }\n\n  private mergeInternalAndStruct(l: InternalDictStructMerge<any, any, any, any>, r: Struct<any>) {\n    return new InternalDictStructMerge(this.mergeStructs(l.s, r), l.d);\n  }\n\n  private mergeInternalAndIntersect(\n    l: InternalDictStructMerge<any, any, any, any>,\n    r: MergeIntersect<any, any, any, any>\n  ): MergeableType<any> | InternalDictStructMerge<any, any, any, any> {\n    return merge(r.merged, {\n      dict: merged => this.mergeInternalAndDict(l, merged),\n      partial: merged => this.mergeInternalAndStruct(l, merged.reify()),\n      struct: merged => this.mergeInternalAndStruct(l, merged),\n      merge: () => {\n        throw `MergeIntersect can't be a child of a MergeIntersect; structural internal error`\n      },\n      internal: merged => this.mergeInternalAndInternal(l, merged),\n    });\n  }\n\n  private mergeInternalAndInternal(\n    l: InternalDictStructMerge<any, any, any, any>,\n    r: InternalDictStructMerge<any, any, any, any>,\n  ) {\n    return new InternalDictStructMerge(\n      this.mergeStructs(l.s, r.s),\n      this.mergeDicts(l.d, r.d),\n    )\n  }\n\n  private mergeDicts(l: Dict<L>, r: Dict<R>): Dict<L & R> {\n    return dict(l.valueType.and(r.valueType));\n  }\n\n  private mergeDictAndStruct(l: Dict<L>, r: StructFor<R>) {\n    return new InternalDictStructMerge(r, l);\n  }\n\n  private mergeStructs(l: Struct<any>, r: Struct<any>) {\n    const definition: { [key: string]: FieldDef } = {};\n\n    for(const prop in l.definition) {\n      definition[prop] = l.definition[prop];\n    }\n    for(const prop in r.definition) {\n      const existing = definition[prop];\n      const merging = r.definition[prop];\n      // If it's an additional key, slap it in\n      if(existing == null) definition[prop] = r.definition[prop];\n      // If it's a missing key, handle\n      else if(existing instanceof MissingKey) {\n        // Missing keys are stricter than optional, so both converge to missing key\n        if(merging instanceof MissingKey || merging instanceof OptionalKey) {\n          definition[prop] = new MissingKey(existing.type.and(merging.type));\n        }\n        // The strictest is just a raw type, so unwrap and merge\n        else {\n          definition[prop] = existing.type.and(merging);\n        }\n      }\n      // If it's an optional key, handle\n      else if(existing instanceof OptionalKey) {\n        // Missing key is stricter than optional, so it wins\n        if(merging instanceof MissingKey) {\n          definition[prop] = new MissingKey(existing.type.and(merging.type));\n        }\n        // Two optionals merge into an optional\n        else if(merging instanceof OptionalKey) {\n          definition[prop] = new OptionalKey(existing.type.and(merging.type));\n        }\n        // A raw type is stricter than optional, so it unwraps the optionality\n        else {\n          definition[prop] = existing.type.and(merging);\n        }\n      }\n      else {\n        // Raw types are stricter than missing or optional types\n        if(merging instanceof MissingKey || merging instanceof OptionalKey) {\n          definition[prop] = existing.and(merging.type);\n        }\n        // Finally, merging two raw types\n        else {\n          definition[prop] = existing.and(merging);\n        }\n      }\n    }\n\n    return new Struct(definition, l.exact && r.exact);\n  }\n}\n\ntype MergeHandlers = {\n    dict: (d: Dict<any>) => MergeResult,\n    partial: (p: PartialStruct<any>) => MergeResult,\n    struct: (s: Struct<any>) => MergeResult,\n    merge: (m: MergeIntersect<any, any, any, any>) => MergeResult,\n    internal: (i: InternalDictStructMerge<any, any, any, any>) => MergeResult,\n};\ntype MergeResult = MergeableType<any> | InternalDictStructMerge<any, any, any, any>;\nfunction merge<Input extends MergeableType<any>>(\n  i: Input,\n  handlers: MergeHandlers,\n): MergeResult {\n  if(i instanceof Dict) return handlers.dict(i);\n  if(i instanceof PartialStruct) return handlers.partial(i);\n  if(i instanceof Struct) return handlers.struct(i);\n  if(i instanceof MergeIntersect) return handlers.merge(i);\n  if(i instanceof InternalDictStructMerge) return handlers.internal(i);\n  throw `Unknown type ${i}`;\n}\n\nclass InternalDictStructMerge<\n  SVal extends TypeStruct, DVal,\n  S extends Struct<SVal>,\n  D extends Dict<DVal>\n> extends Type<GetType<S> & GetType<D>> {\n  readonly s: S;\n  constructor(s: S, readonly d: D) {\n    super();\n    this.s = new Struct(s.definition, false) as S;\n  }\n\n  check(val: any) {\n    const dResult = this.d.check(val);\n    if(dResult instanceof Err) return dResult;\n    const sResult = this.s.check(val);\n    if(sResult instanceof Err) return sResult;\n    return val;\n  }\n\n  sliceResult(val: any) {\n    const dResult = this.d.sliceResult(val);\n    if(dResult instanceof Err) return dResult;\n    const sResult = this.s.sliceResult(val);\n    return Object.assign({}, dResult, sResult) as GetType<S> & GetType<D>;\n  }\n}\n\nexport const Nested = [\n  Struct,\n  PartialStruct,\n  Dict,\n  Either,\n  DefaultIntersect,\n  MergeIntersect,\n  Comment,\n] as const;\nexport type NestedType = InstanceType<(typeof Nested)[number]>;\n\nfunction deepPartialKind(kind: Type<any>): Type<any> {\n  if(isNested(kind)) return handleNested(kind);\n  return kind;\n}\n\nfunction handleNested(kind: NestedType): Type<any> {\n  if(kind instanceof Struct) {\n    if(hasNested(kind)) return deepPartial(kind);\n    return new PartialStruct(kind);\n  }\n  if(kind instanceof PartialStruct) return deepPartial(kind.struct);\n  if(kind instanceof Comment) return new Comment(kind.commentStr, deepPartialKind(kind.wrapped));\n  if(kind instanceof Dict) return new Dict(deepPartialKind(kind.valueType), kind.namedKey);\n  if(kind instanceof Either) return new Either(deepPartialKind(kind.l), deepPartialKind(kind.r));\n  if(kind instanceof MergeIntersect) return new DefaultIntersect(deepPartialKind(kind.l), deepPartialKind(kind.r));\n  return new DefaultIntersect(deepPartialKind(kind.l), deepPartialKind(kind.r));\n}\n\nfunction isNested(kind: Type<any> | NestedType): kind is NestedType {\n  for(const t of Nested) {\n    if(kind instanceof t) return true;\n  }\n  return false;\n}\n\nfunction hasNested(struct: Struct<any>) {\n  for(const k in struct.definition) {\n    if(isNested(struct.definition[k])) return true;\n  }\n  return false;\n}\n\nexport function partial<T extends TypeStruct>(struct: Struct<T>): PartialStruct<T> {\n  return new PartialStruct(struct);\n}\n"]}
|