2021-03-10 22:15:53 +00:00
|
|
|
import * as _ from "@preserves/core";
|
|
|
|
|
|
|
|
export const $1 = 1;
|
|
|
|
export const $Boolean = Symbol.for("Boolean");
|
|
|
|
export const $ByteString = Symbol.for("ByteString");
|
|
|
|
export const $Double = Symbol.for("Double");
|
|
|
|
export const $Float = Symbol.for("Float");
|
|
|
|
export const $SignedInteger = Symbol.for("SignedInteger");
|
|
|
|
export const $String = Symbol.for("String");
|
|
|
|
export const $Symbol = Symbol.for("Symbol");
|
|
|
|
export const $and = Symbol.for("and");
|
|
|
|
export const $atom = Symbol.for("atom");
|
|
|
|
export const $definitions = Symbol.for("definitions");
|
|
|
|
export const $dict = Symbol.for("dict");
|
|
|
|
export const $dictof = Symbol.for("dictof");
|
|
|
|
export const $lit = Symbol.for("lit");
|
|
|
|
export const $named = Symbol.for("named");
|
|
|
|
export const $or = Symbol.for("or");
|
|
|
|
export const $pointer = Symbol.for("pointer");
|
|
|
|
export const $rec = Symbol.for("rec");
|
|
|
|
export const $ref = Symbol.for("ref");
|
|
|
|
export const $schema = Symbol.for("schema");
|
|
|
|
export const $setof = Symbol.for("setof");
|
|
|
|
export const $tuple = Symbol.for("tuple");
|
|
|
|
export const $tuple_STAR_ = Symbol.for("tuple*");
|
|
|
|
export const $version = Symbol.for("version");
|
2021-03-11 16:59:40 +00:00
|
|
|
export const __lit5 = false;
|
2021-03-10 22:15:53 +00:00
|
|
|
|
|
|
|
export const Schema = _.Record.makeConstructor<{
|
2021-03-17 13:36:44 +00:00
|
|
|
"_field0": (
|
2021-03-10 22:15:53 +00:00
|
|
|
{
|
|
|
|
get(k: typeof $version): Version;
|
2021-03-11 16:59:40 +00:00
|
|
|
get(k: typeof $pointer): PointerName;
|
2021-03-17 11:20:50 +00:00
|
|
|
get(k: typeof $definitions): _.KeyedDictionary<symbol, Definition, _ptr>;
|
2021-03-10 22:15:53 +00:00
|
|
|
has(k: typeof $version): true;
|
2021-03-11 16:59:40 +00:00
|
|
|
has(k: typeof $pointer): true;
|
2021-03-10 22:15:53 +00:00
|
|
|
has(k: typeof $definitions): true;
|
2021-03-17 11:20:50 +00:00
|
|
|
} & _.Dictionary<_ptr>
|
2021-03-10 22:15:53 +00:00
|
|
|
)
|
2021-03-17 13:36:44 +00:00
|
|
|
}, _ptr>()($schema, ["_field0"]);
|
2021-03-10 22:15:53 +00:00
|
|
|
|
|
|
|
export type Schema = _.Record<
|
|
|
|
(typeof $schema),
|
|
|
|
[
|
|
|
|
(
|
|
|
|
{
|
|
|
|
get(k: typeof $version): Version;
|
2021-03-11 16:59:40 +00:00
|
|
|
get(k: typeof $pointer): PointerName;
|
2021-03-17 11:20:50 +00:00
|
|
|
get(k: typeof $definitions): _.KeyedDictionary<symbol, Definition, _ptr>;
|
2021-03-10 22:15:53 +00:00
|
|
|
has(k: typeof $version): true;
|
2021-03-11 16:59:40 +00:00
|
|
|
has(k: typeof $pointer): true;
|
2021-03-10 22:15:53 +00:00
|
|
|
has(k: typeof $definitions): true;
|
2021-03-17 11:20:50 +00:00
|
|
|
} & _.Dictionary<_ptr>
|
2021-03-10 22:15:53 +00:00
|
|
|
)
|
2021-03-11 16:59:40 +00:00
|
|
|
],
|
|
|
|
_ptr
|
2021-03-10 22:15:53 +00:00
|
|
|
>;
|
|
|
|
|
|
|
|
export type Version = (typeof $1);
|
|
|
|
|
2021-03-11 16:59:40 +00:00
|
|
|
export type PointerName = (Ref | (typeof __lit5));
|
|
|
|
|
2021-03-17 13:36:44 +00:00
|
|
|
export type Definition = (_.Record<(typeof $or), [Array<NamedAlternative>], _ptr> | Alternative);
|
|
|
|
|
|
|
|
export type NamedAlternative = [symbol, Alternative];
|
2021-03-17 11:20:50 +00:00
|
|
|
|
|
|
|
export type Alternative = (_.Record<(typeof $and), [Array<Pattern>], _ptr> | Pattern);
|
|
|
|
|
2021-03-17 13:36:44 +00:00
|
|
|
export type Pattern = (SimplePattern | CompoundPattern);
|
|
|
|
|
|
|
|
export type SimplePattern = (
|
2021-03-17 11:20:50 +00:00
|
|
|
_.Record<(typeof $atom), [AtomKind], _ptr> |
|
2021-03-11 16:59:40 +00:00
|
|
|
_.Record<(typeof $pointer), [], _ptr> |
|
|
|
|
_.Record<(typeof $lit), [_val], _ptr> |
|
2021-03-17 13:36:44 +00:00
|
|
|
Ref
|
|
|
|
);
|
|
|
|
|
|
|
|
export type CompoundPattern = (
|
2021-03-11 16:59:40 +00:00
|
|
|
_.Record<(typeof $rec), [Pattern, Pattern], _ptr> |
|
|
|
|
_.Record<(typeof $tuple), [Array<NamedPattern>], _ptr> |
|
|
|
|
_.Record<(typeof $tuple_STAR_), [Array<NamedPattern>, NamedPattern], _ptr> |
|
2021-03-17 13:36:44 +00:00
|
|
|
_.Record<(typeof $setof), [SimplePattern], _ptr> |
|
|
|
|
_.Record<(typeof $dictof), [SimplePattern, SimplePattern], _ptr> |
|
|
|
|
_.Record<(typeof $dict), [DictionaryEntries], _ptr>
|
2021-03-10 22:15:53 +00:00
|
|
|
);
|
|
|
|
|
2021-03-17 13:36:44 +00:00
|
|
|
export type DictionaryEntries = _.KeyedDictionary<_val, NamedPattern, _ptr>;
|
|
|
|
|
2021-03-17 11:20:50 +00:00
|
|
|
export type AtomKind = (
|
|
|
|
(typeof $Boolean) |
|
|
|
|
(typeof $Float) |
|
|
|
|
(typeof $Double) |
|
|
|
|
(typeof $SignedInteger) |
|
|
|
|
(typeof $String) |
|
|
|
|
(typeof $ByteString) |
|
|
|
|
(typeof $Symbol)
|
|
|
|
);
|
|
|
|
|
2021-03-17 13:36:44 +00:00
|
|
|
export type NamedPattern = (_.Record<(typeof $named), [symbol, SimplePattern], _ptr> | Pattern);
|
2021-03-10 22:15:53 +00:00
|
|
|
|
2021-03-14 21:59:53 +00:00
|
|
|
export const Ref = _.Record.makeConstructor<{"module": ModulePath, "name": symbol}, _ptr>()($ref, ["module","name"]);
|
2021-03-11 09:56:49 +00:00
|
|
|
|
2021-03-14 21:59:53 +00:00
|
|
|
export type Ref = _.Record<(typeof $ref), [ModulePath, symbol], _ptr>;
|
2021-03-11 09:56:49 +00:00
|
|
|
|
|
|
|
export type ModulePath = Array<symbol>;
|
2021-03-12 10:14:39 +00:00
|
|
|
|
|
|
|
export type _ptr = never;
|
|
|
|
|
|
|
|
export type _val = _.Value<_ptr>;
|
2021-03-11 09:56:49 +00:00
|
|
|
|
2021-03-10 22:15:53 +00:00
|
|
|
|
|
|
|
export function isSchema(v: any): v is Schema {
|
2021-03-11 16:59:40 +00:00
|
|
|
let _tmp0, _tmp1, _tmp2: any;
|
2021-03-10 22:15:53 +00:00
|
|
|
return (
|
2021-03-11 16:59:40 +00:00
|
|
|
_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
|
2021-03-14 20:13:40 +00:00
|
|
|
_.is(v.label, $schema) &&
|
2021-03-10 22:15:53 +00:00
|
|
|
(
|
|
|
|
(v.length === 1) &&
|
|
|
|
(
|
2021-03-17 11:20:50 +00:00
|
|
|
_.Dictionary.isDictionary<_ptr>(v[0]) &&
|
2021-03-10 22:15:53 +00:00
|
|
|
((_tmp0 = v[0].get($version)) !== void 0 && isVersion(_tmp0)) &&
|
2021-03-11 16:59:40 +00:00
|
|
|
((_tmp1 = v[0].get($pointer)) !== void 0 && isPointerName(_tmp1)) &&
|
2021-03-10 22:15:53 +00:00
|
|
|
(
|
2021-03-11 16:59:40 +00:00
|
|
|
(_tmp2 = v[0].get($definitions)) !== void 0 && (
|
2021-03-17 11:20:50 +00:00
|
|
|
_.Dictionary.isDictionary<_ptr>(_tmp2) &&
|
2021-03-10 22:15:53 +00:00
|
|
|
((() => {
|
2021-03-11 16:59:40 +00:00
|
|
|
for (const e of _tmp2) {
|
2021-03-10 22:15:53 +00:00
|
|
|
if (!(typeof e[0] === 'symbol')) return false;
|
2021-03-17 11:20:50 +00:00
|
|
|
if (!(isDefinition(e[1]))) return false;
|
2021-03-10 22:15:53 +00:00
|
|
|
};
|
|
|
|
return true;
|
|
|
|
})())
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2021-03-11 16:59:40 +00:00
|
|
|
export function asSchema(v: any): Schema {
|
|
|
|
if (!isSchema(v)) {throw new TypeError(`Invalid Schema: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
2021-03-11 08:25:17 +00:00
|
|
|
|
2021-03-12 19:41:35 +00:00
|
|
|
export function decodeSchema(d: _.TypedDecoder<_ptr>): Schema | undefined {
|
2021-03-14 20:10:47 +00:00
|
|
|
let result;
|
|
|
|
if (d.openRecord()) {
|
|
|
|
let _tmp3: any;
|
|
|
|
_tmp3 = _.asLiteral(d.nextSymbol(), $schema);
|
|
|
|
if (_tmp3 !== void 0) {
|
|
|
|
let _tmp4, _tmp5, _tmp6, _tmp7, _tmp8: any;
|
|
|
|
_tmp5 = d.next();
|
|
|
|
if (_tmp5 !== void 0 && !((
|
2021-03-17 11:20:50 +00:00
|
|
|
_.Dictionary.isDictionary<_ptr>(_tmp5) &&
|
2021-03-14 20:10:47 +00:00
|
|
|
((_tmp6 = _tmp5.get($version)) !== void 0 && isVersion(_tmp6)) &&
|
|
|
|
((_tmp7 = _tmp5.get($pointer)) !== void 0 && isPointerName(_tmp7)) &&
|
2021-03-12 19:41:35 +00:00
|
|
|
(
|
2021-03-14 20:10:47 +00:00
|
|
|
(_tmp8 = _tmp5.get($definitions)) !== void 0 && (
|
2021-03-17 11:20:50 +00:00
|
|
|
_.Dictionary.isDictionary<_ptr>(_tmp8) &&
|
2021-03-14 20:10:47 +00:00
|
|
|
((() => {
|
|
|
|
for (const e of _tmp8) {
|
|
|
|
if (!(typeof e[0] === 'symbol')) return false;
|
2021-03-17 11:20:50 +00:00
|
|
|
if (!(isDefinition(e[1]))) return false;
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
|
|
|
return true;
|
|
|
|
})())
|
|
|
|
)
|
2021-03-12 19:41:35 +00:00
|
|
|
)
|
2021-03-14 20:10:47 +00:00
|
|
|
))) _tmp5 = void 0;
|
2021-03-17 13:36:44 +00:00
|
|
|
if (_tmp5 !== void 0) {
|
|
|
|
if (d.closeCompound()) _tmp4 = [_tmp5] as [
|
|
|
|
(
|
|
|
|
{
|
|
|
|
get(k: typeof $version): Version;
|
|
|
|
get(k: typeof $pointer): PointerName;
|
|
|
|
get(k: typeof $definitions): _.KeyedDictionary<symbol, Definition, _ptr>;
|
|
|
|
has(k: typeof $version): true;
|
|
|
|
has(k: typeof $pointer): true;
|
|
|
|
has(k: typeof $definitions): true;
|
|
|
|
} & _.Dictionary<_ptr>
|
|
|
|
)
|
|
|
|
];
|
|
|
|
};
|
2021-03-14 20:10:47 +00:00
|
|
|
if (_tmp4 !== void 0) result = _.Record<
|
|
|
|
(typeof $schema),
|
|
|
|
[
|
|
|
|
(
|
|
|
|
{
|
|
|
|
get(k: typeof $version): Version;
|
|
|
|
get(k: typeof $pointer): PointerName;
|
2021-03-17 11:20:50 +00:00
|
|
|
get(k: typeof $definitions): _.KeyedDictionary<symbol, Definition, _ptr>;
|
2021-03-14 20:10:47 +00:00
|
|
|
has(k: typeof $version): true;
|
|
|
|
has(k: typeof $pointer): true;
|
|
|
|
has(k: typeof $definitions): true;
|
2021-03-17 11:20:50 +00:00
|
|
|
} & _.Dictionary<_ptr>
|
2021-03-14 20:10:47 +00:00
|
|
|
)
|
|
|
|
]
|
|
|
|
>(_tmp3 as any, _tmp4 as any);
|
|
|
|
};
|
|
|
|
};
|
|
|
|
return result;
|
2021-03-12 19:41:35 +00:00
|
|
|
}
|
|
|
|
|
2021-03-14 20:13:40 +00:00
|
|
|
export function isVersion(v: any): v is Version {return _.is(v, $1);}
|
2021-03-10 22:15:53 +00:00
|
|
|
|
2021-03-11 16:59:40 +00:00
|
|
|
export function asVersion(v: any): Version {
|
|
|
|
if (!isVersion(v)) {throw new TypeError(`Invalid Version: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
|
|
|
|
2021-03-14 20:10:47 +00:00
|
|
|
export function decodeVersion(d: _.TypedDecoder<_ptr>): Version | undefined {let result; result = _.asLiteral(d.nextSignedInteger(), $1); return result;}
|
2021-03-12 19:41:35 +00:00
|
|
|
|
2021-03-14 20:13:40 +00:00
|
|
|
export function isPointerName(v: any): v is PointerName {return (isRef(v) || _.is(v, __lit5));}
|
2021-03-11 16:59:40 +00:00
|
|
|
|
|
|
|
export function asPointerName(v: any): PointerName {
|
|
|
|
if (!isPointerName(v)) {throw new TypeError(`Invalid PointerName: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
2021-03-11 08:25:17 +00:00
|
|
|
|
2021-03-14 20:10:47 +00:00
|
|
|
export function decodePointerName(d: _.TypedDecoder<_ptr>): PointerName | undefined {
|
|
|
|
let _tmp9: any;
|
|
|
|
let result;
|
|
|
|
_tmp9 = d.mark();
|
|
|
|
result = decodeRef(d);
|
|
|
|
if (result === void 0) {d.restoreMark(_tmp9); result = _.asLiteral(d.nextBoolean(), __lit5);};
|
|
|
|
return result;
|
|
|
|
}
|
2021-03-12 19:41:35 +00:00
|
|
|
|
2021-03-17 11:20:50 +00:00
|
|
|
export function isDefinition(v: any): v is Definition {
|
|
|
|
return (
|
2021-03-10 22:15:53 +00:00
|
|
|
(
|
2021-03-17 11:20:50 +00:00
|
|
|
_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
|
|
|
|
_.is(v.label, $or) &&
|
2021-03-10 22:15:53 +00:00
|
|
|
(
|
2021-03-17 11:20:50 +00:00
|
|
|
(v.length === 1) &&
|
|
|
|
(
|
|
|
|
_.Array.isArray(v[0]) &&
|
|
|
|
!_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v[0]) &&
|
|
|
|
(v[0].length >= 0) &&
|
2021-03-17 13:36:44 +00:00
|
|
|
v[0].every(v => (isNamedAlternative(v)))
|
2021-03-10 22:15:53 +00:00
|
|
|
)
|
2021-03-17 11:20:50 +00:00
|
|
|
)
|
|
|
|
) ||
|
|
|
|
isAlternative(v)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
export function asDefinition(v: any): Definition {
|
|
|
|
if (!isDefinition(v)) {throw new TypeError(`Invalid Definition: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
|
|
|
|
|
|
|
export function decodeDefinition(d: _.TypedDecoder<_ptr>): Definition | undefined {
|
|
|
|
let _tmp10: any;
|
|
|
|
let result;
|
|
|
|
_tmp10 = d.mark();
|
|
|
|
if (d.openRecord()) {
|
|
|
|
let _tmp11: any;
|
|
|
|
_tmp11 = _.asLiteral(d.nextSymbol(), $or);
|
|
|
|
if (_tmp11 !== void 0) {
|
|
|
|
let _tmp12, _tmp13: any;
|
|
|
|
if (d.openSequence()) {
|
|
|
|
let _tmp14: any;
|
|
|
|
{
|
2021-03-17 13:36:44 +00:00
|
|
|
let vN: Array<NamedAlternative> | undefined = [];
|
2021-03-17 11:20:50 +00:00
|
|
|
while (!d.closeCompound()) {
|
|
|
|
_tmp14 = void 0;
|
2021-03-17 13:36:44 +00:00
|
|
|
_tmp14 = decodeNamedAlternative(d);
|
2021-03-17 11:20:50 +00:00
|
|
|
if (_tmp14 === void 0) {vN = void 0; break;};
|
|
|
|
vN.push(_tmp14);
|
|
|
|
};
|
|
|
|
_tmp13 = vN;
|
|
|
|
};
|
|
|
|
};
|
2021-03-17 13:36:44 +00:00
|
|
|
if (_tmp13 !== void 0) {if (d.closeCompound()) _tmp12 = [_tmp13] as [Array<NamedAlternative>];};
|
|
|
|
if (_tmp12 !== void 0) result = _.Record<(typeof $or), [Array<NamedAlternative>]>(_tmp11 as any, _tmp12 as any);
|
2021-03-17 11:20:50 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
if (result === void 0) {d.restoreMark(_tmp10); result = decodeAlternative(d);};
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-03-17 13:36:44 +00:00
|
|
|
export function isNamedAlternative(v: any): v is NamedAlternative {
|
|
|
|
return (
|
|
|
|
_.Array.isArray(v) &&
|
|
|
|
!_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
|
|
|
|
(v.length === 2) &&
|
|
|
|
typeof v[0] === 'symbol' &&
|
|
|
|
isAlternative(v[1])
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
export function asNamedAlternative(v: any): NamedAlternative {
|
|
|
|
if (!isNamedAlternative(v)) {throw new TypeError(`Invalid NamedAlternative: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
|
|
|
|
|
|
|
export function decodeNamedAlternative(d: _.TypedDecoder<_ptr>): NamedAlternative | undefined {
|
|
|
|
let _tmp15, _tmp16: any;
|
|
|
|
let result;
|
|
|
|
if (d.openSequence()) {
|
|
|
|
_tmp15 = d.nextSymbol();
|
|
|
|
if (_tmp15 !== void 0) {
|
|
|
|
_tmp16 = decodeAlternative(d);
|
|
|
|
if (_tmp16 !== void 0) {if (d.closeCompound()) result = [_tmp15, _tmp16] as [symbol, Alternative];};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-03-17 11:20:50 +00:00
|
|
|
export function isAlternative(v: any): v is Alternative {
|
|
|
|
return (
|
|
|
|
(
|
|
|
|
_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
|
|
|
|
_.is(v.label, $and) &&
|
|
|
|
(
|
|
|
|
(v.length === 1) &&
|
|
|
|
(
|
|
|
|
_.Array.isArray(v[0]) &&
|
|
|
|
!_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v[0]) &&
|
|
|
|
(v[0].length >= 0) &&
|
|
|
|
v[0].every(v => (isPattern(v)))
|
|
|
|
)
|
|
|
|
)
|
|
|
|
) ||
|
|
|
|
isPattern(v)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
export function asAlternative(v: any): Alternative {
|
|
|
|
if (!isAlternative(v)) {throw new TypeError(`Invalid Alternative: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
|
|
|
|
|
|
|
export function decodeAlternative(d: _.TypedDecoder<_ptr>): Alternative | undefined {
|
|
|
|
let _tmp17: any;
|
|
|
|
let result;
|
|
|
|
_tmp17 = d.mark();
|
|
|
|
if (d.openRecord()) {
|
|
|
|
let _tmp18: any;
|
|
|
|
_tmp18 = _.asLiteral(d.nextSymbol(), $and);
|
|
|
|
if (_tmp18 !== void 0) {
|
|
|
|
let _tmp19, _tmp20: any;
|
|
|
|
if (d.openSequence()) {
|
|
|
|
let _tmp21: any;
|
|
|
|
{
|
|
|
|
let vN: Array<Pattern> | undefined = [];
|
|
|
|
while (!d.closeCompound()) {
|
|
|
|
_tmp21 = void 0;
|
|
|
|
_tmp21 = decodePattern(d);
|
|
|
|
if (_tmp21 === void 0) {vN = void 0; break;};
|
|
|
|
vN.push(_tmp21);
|
|
|
|
};
|
|
|
|
_tmp20 = vN;
|
|
|
|
};
|
|
|
|
};
|
2021-03-17 13:36:44 +00:00
|
|
|
if (_tmp20 !== void 0) {if (d.closeCompound()) _tmp19 = [_tmp20] as [Array<Pattern>];};
|
2021-03-17 11:20:50 +00:00
|
|
|
if (_tmp19 !== void 0) result = _.Record<(typeof $and), [Array<Pattern>]>(_tmp18 as any, _tmp19 as any);
|
|
|
|
};
|
|
|
|
};
|
|
|
|
if (result === void 0) {d.restoreMark(_tmp17); result = decodePattern(d);};
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-03-17 13:36:44 +00:00
|
|
|
export function isPattern(v: any): v is Pattern {return (isSimplePattern(v) || isCompoundPattern(v));}
|
|
|
|
|
|
|
|
export function asPattern(v: any): Pattern {
|
|
|
|
if (!isPattern(v)) {throw new TypeError(`Invalid Pattern: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
|
|
|
|
|
|
|
export function decodePattern(d: _.TypedDecoder<_ptr>): Pattern | undefined {
|
|
|
|
let _tmp22: any;
|
|
|
|
let result;
|
|
|
|
_tmp22 = d.mark();
|
|
|
|
result = decodeSimplePattern(d);
|
|
|
|
if (result === void 0) {d.restoreMark(_tmp22); result = decodeCompoundPattern(d);};
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
export function isSimplePattern(v: any): v is SimplePattern {
|
2021-03-17 11:20:50 +00:00
|
|
|
return _.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) && (
|
|
|
|
(
|
|
|
|
(_.is(v.label, $atom) && ((v.length === 1) && isAtomKind(v[0]))) ||
|
2021-03-14 20:13:40 +00:00
|
|
|
(_.is(v.label, $pointer) && ((v.length === 0))) ||
|
|
|
|
(_.is(v.label, $lit) && ((v.length === 1) && true)) ||
|
2021-03-10 22:15:53 +00:00
|
|
|
(
|
2021-03-14 21:59:53 +00:00
|
|
|
_.is(v.label, $ref) && ((v.length === 2) && isModulePath(v[0]) && typeof v[1] === 'symbol')
|
2021-03-17 13:36:44 +00:00
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
export function asSimplePattern(v: any): SimplePattern {
|
|
|
|
if (!isSimplePattern(v)) {throw new TypeError(`Invalid SimplePattern: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
|
|
|
|
|
|
|
export function decodeSimplePattern(d: _.TypedDecoder<_ptr>): SimplePattern | undefined {
|
|
|
|
let result;
|
|
|
|
if (d.openRecord()) {
|
|
|
|
let _tmp23, _tmp24: any;
|
|
|
|
_tmp23 = d.next();
|
|
|
|
_tmp24 = d.mark();
|
|
|
|
if (_.is(_tmp23, $atom)) {
|
|
|
|
let _tmp25, _tmp26: any;
|
|
|
|
_tmp26 = decodeAtomKind(d);
|
|
|
|
if (_tmp26 !== void 0) {if (d.closeCompound()) _tmp25 = [_tmp26] as [AtomKind];};
|
|
|
|
if (_tmp25 !== void 0) result = _.Record<(typeof $atom), [AtomKind]>(_tmp23 as any, _tmp25 as any);
|
|
|
|
};
|
|
|
|
if (result === void 0) {
|
|
|
|
d.restoreMark(_tmp24);
|
|
|
|
if (_.is(_tmp23, $pointer)) {
|
|
|
|
let _tmp27: any;
|
|
|
|
if (d.closeCompound()) _tmp27 = [] as [];
|
|
|
|
if (_tmp27 !== void 0) result = _.Record<(typeof $pointer), []>(_tmp23 as any, _tmp27 as any);
|
|
|
|
};
|
|
|
|
if (result === void 0) {
|
|
|
|
d.restoreMark(_tmp24);
|
|
|
|
if (_.is(_tmp23, $lit)) {
|
|
|
|
let _tmp28, _tmp29: any;
|
|
|
|
_tmp29 = d.next();
|
|
|
|
if (_tmp29 !== void 0) {if (d.closeCompound()) _tmp28 = [_tmp29] as [_val];};
|
|
|
|
if (_tmp28 !== void 0) result = _.Record<(typeof $lit), [_val]>(_tmp23 as any, _tmp28 as any);
|
|
|
|
};
|
|
|
|
if (result === void 0) {
|
|
|
|
d.restoreMark(_tmp24);
|
|
|
|
if (_.is(_tmp23, $ref)) {
|
|
|
|
let _tmp30, _tmp31, _tmp32: any;
|
|
|
|
_tmp31 = decodeModulePath(d);
|
|
|
|
if (_tmp31 !== void 0) {
|
|
|
|
_tmp32 = d.nextSymbol();
|
|
|
|
if (_tmp32 !== void 0) {if (d.closeCompound()) _tmp30 = [_tmp31, _tmp32] as [ModulePath, symbol];};
|
|
|
|
};
|
|
|
|
if (_tmp30 !== void 0) result = _.Record<(typeof $ref), [ModulePath, symbol]>(_tmp23 as any, _tmp30 as any);
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
export function isCompoundPattern(v: any): v is CompoundPattern {
|
|
|
|
return _.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) && (
|
|
|
|
(
|
2021-03-10 22:15:53 +00:00
|
|
|
(
|
2021-03-14 20:13:40 +00:00
|
|
|
_.is(v.label, $rec) && ((v.length === 2) && isPattern(v[0]) && isPattern(v[1]))
|
2021-03-14 20:10:47 +00:00
|
|
|
) ||
|
|
|
|
(
|
2021-03-14 20:13:40 +00:00
|
|
|
_.is(v.label, $tuple) && (
|
2021-03-14 20:10:47 +00:00
|
|
|
(v.length === 1) &&
|
|
|
|
(
|
|
|
|
_.Array.isArray(v[0]) &&
|
|
|
|
!_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v[0]) &&
|
|
|
|
(v[0].length >= 0) &&
|
|
|
|
v[0].every(v => (isNamedPattern(v)))
|
|
|
|
)
|
2021-03-10 22:15:53 +00:00
|
|
|
)
|
2021-03-14 20:10:47 +00:00
|
|
|
) ||
|
2021-03-10 22:15:53 +00:00
|
|
|
(
|
2021-03-14 20:13:40 +00:00
|
|
|
_.is(v.label, $tuple_STAR_) && (
|
2021-03-14 20:10:47 +00:00
|
|
|
(v.length === 2) &&
|
|
|
|
(
|
|
|
|
_.Array.isArray(v[0]) &&
|
|
|
|
!_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v[0]) &&
|
|
|
|
(v[0].length >= 0) &&
|
|
|
|
v[0].every(v => (isNamedPattern(v)))
|
|
|
|
) &&
|
|
|
|
isNamedPattern(v[1])
|
|
|
|
)
|
|
|
|
) ||
|
2021-03-17 13:36:44 +00:00
|
|
|
(_.is(v.label, $setof) && ((v.length === 1) && isSimplePattern(v[0]))) ||
|
2021-03-10 22:15:53 +00:00
|
|
|
(
|
2021-03-17 13:36:44 +00:00
|
|
|
_.is(v.label, $dictof) && ((v.length === 2) && isSimplePattern(v[0]) && isSimplePattern(v[1]))
|
2021-03-14 20:10:47 +00:00
|
|
|
) ||
|
2021-03-17 13:36:44 +00:00
|
|
|
(_.is(v.label, $dict) && ((v.length === 1) && isDictionaryEntries(v[0])))
|
2021-03-10 22:15:53 +00:00
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2021-03-17 13:36:44 +00:00
|
|
|
export function asCompoundPattern(v: any): CompoundPattern {
|
|
|
|
if (!isCompoundPattern(v)) {throw new TypeError(`Invalid CompoundPattern: ${_.stringify(v)}`);} else {return v;};
|
2021-03-11 16:59:40 +00:00
|
|
|
}
|
2021-03-11 08:25:17 +00:00
|
|
|
|
2021-03-17 13:36:44 +00:00
|
|
|
export function decodeCompoundPattern(d: _.TypedDecoder<_ptr>): CompoundPattern | undefined {
|
2021-03-14 20:10:47 +00:00
|
|
|
let result;
|
|
|
|
if (d.openRecord()) {
|
2021-03-17 13:36:44 +00:00
|
|
|
let _tmp33, _tmp34: any;
|
|
|
|
_tmp33 = d.next();
|
|
|
|
_tmp34 = d.mark();
|
|
|
|
if (_.is(_tmp33, $rec)) {
|
|
|
|
let _tmp35, _tmp36, _tmp37: any;
|
|
|
|
_tmp36 = decodePattern(d);
|
|
|
|
if (_tmp36 !== void 0) {
|
|
|
|
_tmp37 = decodePattern(d);
|
|
|
|
if (_tmp37 !== void 0) {if (d.closeCompound()) _tmp35 = [_tmp36, _tmp37] as [Pattern, Pattern];};
|
|
|
|
};
|
|
|
|
if (_tmp35 !== void 0) result = _.Record<(typeof $rec), [Pattern, Pattern]>(_tmp33 as any, _tmp35 as any);
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
|
|
|
if (result === void 0) {
|
2021-03-17 13:36:44 +00:00
|
|
|
d.restoreMark(_tmp34);
|
|
|
|
if (_.is(_tmp33, $tuple)) {
|
|
|
|
let _tmp38, _tmp39: any;
|
|
|
|
if (d.openSequence()) {
|
|
|
|
let _tmp40: any;
|
|
|
|
{
|
|
|
|
let vN: Array<NamedPattern> | undefined = [];
|
|
|
|
while (!d.closeCompound()) {
|
|
|
|
_tmp40 = void 0;
|
|
|
|
_tmp40 = decodeNamedPattern(d);
|
|
|
|
if (_tmp40 === void 0) {vN = void 0; break;};
|
|
|
|
vN.push(_tmp40);
|
|
|
|
};
|
|
|
|
_tmp39 = vN;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
if (_tmp39 !== void 0) {if (d.closeCompound()) _tmp38 = [_tmp39] as [Array<NamedPattern>];};
|
|
|
|
if (_tmp38 !== void 0) result = _.Record<(typeof $tuple), [Array<NamedPattern>]>(_tmp33 as any, _tmp38 as any);
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
|
|
|
if (result === void 0) {
|
2021-03-17 13:36:44 +00:00
|
|
|
d.restoreMark(_tmp34);
|
|
|
|
if (_.is(_tmp33, $tuple_STAR_)) {
|
|
|
|
let _tmp41, _tmp42, _tmp43: any;
|
|
|
|
if (d.openSequence()) {
|
|
|
|
let _tmp44: any;
|
|
|
|
{
|
|
|
|
let vN: Array<NamedPattern> | undefined = [];
|
|
|
|
while (!d.closeCompound()) {
|
|
|
|
_tmp44 = void 0;
|
|
|
|
_tmp44 = decodeNamedPattern(d);
|
|
|
|
if (_tmp44 === void 0) {vN = void 0; break;};
|
|
|
|
vN.push(_tmp44);
|
|
|
|
};
|
|
|
|
_tmp42 = vN;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
if (_tmp42 !== void 0) {
|
|
|
|
_tmp43 = decodeNamedPattern(d);
|
|
|
|
if (_tmp43 !== void 0) {
|
|
|
|
if (d.closeCompound()) _tmp41 = [_tmp42, _tmp43] as [Array<NamedPattern>, NamedPattern];
|
|
|
|
};
|
|
|
|
};
|
|
|
|
if (_tmp41 !== void 0) result = _.Record<(typeof $tuple_STAR_), [Array<NamedPattern>, NamedPattern]>(_tmp33 as any, _tmp41 as any);
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
|
|
|
if (result === void 0) {
|
2021-03-17 13:36:44 +00:00
|
|
|
d.restoreMark(_tmp34);
|
|
|
|
if (_.is(_tmp33, $setof)) {
|
|
|
|
let _tmp45, _tmp46: any;
|
|
|
|
_tmp46 = decodeSimplePattern(d);
|
|
|
|
if (_tmp46 !== void 0) {if (d.closeCompound()) _tmp45 = [_tmp46] as [SimplePattern];};
|
|
|
|
if (_tmp45 !== void 0) result = _.Record<(typeof $setof), [SimplePattern]>(_tmp33 as any, _tmp45 as any);
|
2021-03-12 19:41:35 +00:00
|
|
|
};
|
2021-03-14 20:10:47 +00:00
|
|
|
if (result === void 0) {
|
2021-03-17 13:36:44 +00:00
|
|
|
d.restoreMark(_tmp34);
|
|
|
|
if (_.is(_tmp33, $dictof)) {
|
|
|
|
let _tmp47, _tmp48, _tmp49: any;
|
|
|
|
_tmp48 = decodeSimplePattern(d);
|
|
|
|
if (_tmp48 !== void 0) {
|
|
|
|
_tmp49 = decodeSimplePattern(d);
|
|
|
|
if (_tmp49 !== void 0) {
|
|
|
|
if (d.closeCompound()) _tmp47 = [_tmp48, _tmp49] as [SimplePattern, SimplePattern];
|
|
|
|
};
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
2021-03-17 13:36:44 +00:00
|
|
|
if (_tmp47 !== void 0) result = _.Record<(typeof $dictof), [SimplePattern, SimplePattern]>(_tmp33 as any, _tmp47 as any);
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
|
|
|
if (result === void 0) {
|
2021-03-17 13:36:44 +00:00
|
|
|
d.restoreMark(_tmp34);
|
|
|
|
if (_.is(_tmp33, $dict)) {
|
|
|
|
let _tmp50, _tmp51: any;
|
|
|
|
_tmp51 = decodeDictionaryEntries(d);
|
|
|
|
if (_tmp51 !== void 0) {if (d.closeCompound()) _tmp50 = [_tmp51] as [DictionaryEntries];};
|
|
|
|
if (_tmp50 !== void 0) result = _.Record<(typeof $dict), [DictionaryEntries]>(_tmp33 as any, _tmp50 as any);
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
return result;
|
2021-03-12 19:41:35 +00:00
|
|
|
}
|
|
|
|
|
2021-03-17 13:36:44 +00:00
|
|
|
export function isDictionaryEntries(v: any): v is DictionaryEntries {
|
|
|
|
return (
|
|
|
|
_.Dictionary.isDictionary<_ptr>(v) &&
|
|
|
|
((() => {
|
|
|
|
for (const e of v) {if (!(true)) return false; if (!(isNamedPattern(e[1]))) return false;};
|
|
|
|
return true;
|
|
|
|
})())
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
export function asDictionaryEntries(v: any): DictionaryEntries {
|
|
|
|
if (!isDictionaryEntries(v)) {throw new TypeError(`Invalid DictionaryEntries: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
|
|
|
|
|
|
|
export function decodeDictionaryEntries(d: _.TypedDecoder<_ptr>): DictionaryEntries | undefined {
|
|
|
|
let result;
|
|
|
|
if (d.openDictionary()) {
|
|
|
|
let r: _.KeyedDictionary<_val, NamedPattern, _ptr> | undefined = new _.KeyedDictionary();
|
|
|
|
while (!d.closeCompound()) {
|
|
|
|
let K: undefined | _val = void 0;
|
|
|
|
K = d.next();
|
|
|
|
if (K === void 0) { r = void 0; break; };
|
|
|
|
let V: undefined | NamedPattern = void 0;
|
|
|
|
V = decodeNamedPattern(d);
|
|
|
|
if (V === void 0) { r = void 0; break; };
|
|
|
|
r.set(K, V);
|
|
|
|
};
|
|
|
|
result = r;
|
|
|
|
};
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-03-17 11:20:50 +00:00
|
|
|
export function isAtomKind(v: any): v is AtomKind {
|
|
|
|
return (
|
|
|
|
_.is(v, $Boolean) ||
|
|
|
|
_.is(v, $Float) ||
|
|
|
|
_.is(v, $Double) ||
|
|
|
|
_.is(v, $SignedInteger) ||
|
|
|
|
_.is(v, $String) ||
|
|
|
|
_.is(v, $ByteString) ||
|
|
|
|
_.is(v, $Symbol)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
export function asAtomKind(v: any): AtomKind {
|
|
|
|
if (!isAtomKind(v)) {throw new TypeError(`Invalid AtomKind: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
|
|
|
|
|
|
|
export function decodeAtomKind(d: _.TypedDecoder<_ptr>): AtomKind | undefined {
|
2021-03-17 13:36:44 +00:00
|
|
|
let _tmp52: any;
|
2021-03-17 11:20:50 +00:00
|
|
|
let result;
|
2021-03-17 13:36:44 +00:00
|
|
|
_tmp52 = d.mark();
|
2021-03-17 11:20:50 +00:00
|
|
|
result = _.asLiteral(d.nextSymbol(), $Boolean);
|
|
|
|
if (result === void 0) {
|
2021-03-17 13:36:44 +00:00
|
|
|
d.restoreMark(_tmp52);
|
2021-03-17 11:20:50 +00:00
|
|
|
result = _.asLiteral(d.nextSymbol(), $Float);
|
|
|
|
if (result === void 0) {
|
2021-03-17 13:36:44 +00:00
|
|
|
d.restoreMark(_tmp52);
|
2021-03-17 11:20:50 +00:00
|
|
|
result = _.asLiteral(d.nextSymbol(), $Double);
|
|
|
|
if (result === void 0) {
|
2021-03-17 13:36:44 +00:00
|
|
|
d.restoreMark(_tmp52);
|
2021-03-17 11:20:50 +00:00
|
|
|
result = _.asLiteral(d.nextSymbol(), $SignedInteger);
|
|
|
|
if (result === void 0) {
|
2021-03-17 13:36:44 +00:00
|
|
|
d.restoreMark(_tmp52);
|
2021-03-17 11:20:50 +00:00
|
|
|
result = _.asLiteral(d.nextSymbol(), $String);
|
|
|
|
if (result === void 0) {
|
2021-03-17 13:36:44 +00:00
|
|
|
d.restoreMark(_tmp52);
|
2021-03-17 11:20:50 +00:00
|
|
|
result = _.asLiteral(d.nextSymbol(), $ByteString);
|
2021-03-17 13:36:44 +00:00
|
|
|
if (result === void 0) {d.restoreMark(_tmp52); result = _.asLiteral(d.nextSymbol(), $Symbol);};
|
2021-03-17 11:20:50 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-03-10 22:15:53 +00:00
|
|
|
export function isNamedPattern(v: any): v is NamedPattern {
|
|
|
|
return (
|
|
|
|
(
|
2021-03-11 16:59:40 +00:00
|
|
|
_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
|
2021-03-14 20:13:40 +00:00
|
|
|
_.is(v.label, $named) &&
|
2021-03-17 13:36:44 +00:00
|
|
|
((v.length === 2) && typeof v[0] === 'symbol' && isSimplePattern(v[1]))
|
2021-03-10 22:15:53 +00:00
|
|
|
) ||
|
|
|
|
isPattern(v)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2021-03-11 08:25:17 +00:00
|
|
|
export function asNamedPattern(v: any): NamedPattern {
|
2021-03-11 16:59:40 +00:00
|
|
|
if (!isNamedPattern(v)) {throw new TypeError(`Invalid NamedPattern: ${_.stringify(v)}`);} else {return v;};
|
2021-03-11 08:25:17 +00:00
|
|
|
}
|
|
|
|
|
2021-03-12 19:41:35 +00:00
|
|
|
export function decodeNamedPattern(d: _.TypedDecoder<_ptr>): NamedPattern | undefined {
|
2021-03-17 13:36:44 +00:00
|
|
|
let _tmp53: any;
|
2021-03-14 20:10:47 +00:00
|
|
|
let result;
|
2021-03-17 13:36:44 +00:00
|
|
|
_tmp53 = d.mark();
|
2021-03-14 20:10:47 +00:00
|
|
|
if (d.openRecord()) {
|
2021-03-17 13:36:44 +00:00
|
|
|
let _tmp54: any;
|
|
|
|
_tmp54 = _.asLiteral(d.nextSymbol(), $named);
|
|
|
|
if (_tmp54 !== void 0) {
|
|
|
|
let _tmp55, _tmp56, _tmp57: any;
|
|
|
|
_tmp56 = d.nextSymbol();
|
|
|
|
if (_tmp56 !== void 0) {
|
|
|
|
_tmp57 = decodeSimplePattern(d);
|
|
|
|
if (_tmp57 !== void 0) {if (d.closeCompound()) _tmp55 = [_tmp56, _tmp57] as [symbol, SimplePattern];};
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
2021-03-17 13:36:44 +00:00
|
|
|
if (_tmp55 !== void 0) result = _.Record<(typeof $named), [symbol, SimplePattern]>(_tmp54 as any, _tmp55 as any);
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
|
|
|
};
|
2021-03-17 13:36:44 +00:00
|
|
|
if (result === void 0) {d.restoreMark(_tmp53); result = decodePattern(d);};
|
2021-03-14 20:10:47 +00:00
|
|
|
return result;
|
2021-03-12 19:41:35 +00:00
|
|
|
}
|
|
|
|
|
2021-03-11 09:56:49 +00:00
|
|
|
export function isRef(v: any): v is Ref {
|
|
|
|
return (
|
2021-03-11 16:59:40 +00:00
|
|
|
_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
|
2021-03-14 20:13:40 +00:00
|
|
|
_.is(v.label, $ref) &&
|
2021-03-14 21:59:53 +00:00
|
|
|
((v.length === 2) && isModulePath(v[0]) && typeof v[1] === 'symbol')
|
2021-03-11 09:56:49 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2021-03-11 16:59:40 +00:00
|
|
|
export function asRef(v: any): Ref {
|
|
|
|
if (!isRef(v)) {throw new TypeError(`Invalid Ref: ${_.stringify(v)}`);} else {return v;};
|
|
|
|
}
|
2021-03-11 09:56:49 +00:00
|
|
|
|
2021-03-12 19:41:35 +00:00
|
|
|
export function decodeRef(d: _.TypedDecoder<_ptr>): Ref | undefined {
|
2021-03-14 20:10:47 +00:00
|
|
|
let result;
|
|
|
|
if (d.openRecord()) {
|
2021-03-17 13:36:44 +00:00
|
|
|
let _tmp58: any;
|
|
|
|
_tmp58 = _.asLiteral(d.nextSymbol(), $ref);
|
|
|
|
if (_tmp58 !== void 0) {
|
|
|
|
let _tmp59, _tmp60, _tmp61: any;
|
|
|
|
_tmp60 = decodeModulePath(d);
|
|
|
|
if (_tmp60 !== void 0) {
|
|
|
|
_tmp61 = d.nextSymbol();
|
|
|
|
if (_tmp61 !== void 0) {if (d.closeCompound()) _tmp59 = [_tmp60, _tmp61] as [ModulePath, symbol];};
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
2021-03-17 13:36:44 +00:00
|
|
|
if (_tmp59 !== void 0) result = _.Record<(typeof $ref), [ModulePath, symbol]>(_tmp58 as any, _tmp59 as any);
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
return result;
|
2021-03-12 19:41:35 +00:00
|
|
|
}
|
|
|
|
|
2021-03-11 09:56:49 +00:00
|
|
|
export function isModulePath(v: any): v is ModulePath {
|
|
|
|
return (
|
|
|
|
_.Array.isArray(v) &&
|
2021-03-11 16:59:40 +00:00
|
|
|
!_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
|
2021-03-11 09:56:49 +00:00
|
|
|
(v.length >= 0) &&
|
2021-03-14 20:10:47 +00:00
|
|
|
v.every(v => (typeof v === 'symbol'))
|
2021-03-11 09:56:49 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2021-03-11 13:43:58 +00:00
|
|
|
export function asModulePath(v: any): ModulePath {
|
2021-03-11 16:59:40 +00:00
|
|
|
if (!isModulePath(v)) {throw new TypeError(`Invalid ModulePath: ${_.stringify(v)}`);} else {return v;};
|
2021-03-11 13:43:58 +00:00
|
|
|
}
|
2021-03-10 22:15:53 +00:00
|
|
|
|
2021-03-12 19:41:35 +00:00
|
|
|
export function decodeModulePath(d: _.TypedDecoder<_ptr>): ModulePath | undefined {
|
2021-03-14 20:10:47 +00:00
|
|
|
let result;
|
|
|
|
if (d.openSequence()) {
|
2021-03-17 13:36:44 +00:00
|
|
|
let _tmp62: any;
|
2021-03-14 20:10:47 +00:00
|
|
|
{
|
|
|
|
let vN: Array<symbol> | undefined = [];
|
|
|
|
while (!d.closeCompound()) {
|
2021-03-17 13:36:44 +00:00
|
|
|
_tmp62 = void 0;
|
|
|
|
_tmp62 = d.nextSymbol();
|
|
|
|
if (_tmp62 === void 0) {vN = void 0; break;};
|
|
|
|
vN.push(_tmp62);
|
2021-03-14 20:10:47 +00:00
|
|
|
};
|
|
|
|
result = vN;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
return result;
|
2021-03-12 19:41:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
export const _decodePtr = () => { throw new _.DecodeError("Pointers forbidden"); };
|
|
|
|
|