schemas/libraries/sury/download_compiled/index/unminified.js
schemas/libraries/sury/download_compiled/index/unminified.js
schemas/libraries/sury/download_compiled/index/unminified.js
schemas/libraries/sury/download_compiled/index/unminified.js
var pathEmpty = [];
var pathDynamic = ["[]"];
var inlineUnsafeRe = /["\\\n\r]/;
var inlinedValueFromString = (str) =>
inlineUnsafeRe.test(str)
? JSON.stringify(str)
: `"${str}"`;
var jsIdentRe = /^[A-Za-z_$][\w$]*$/;
var inlinedObjectKey = (key) =>
key === "__proto__"
? '["__proto__"]'
: jsIdentRe.test(key)
? key
: inlinedValueFromString(key);
var inlinedProperty = (
obj,
key,
numeric,
) =>
numeric && /^\d+$/.test(key)
? `${obj}[${key}]`
: key === "__proto__" ||
!jsIdentRe.test(key)
? `${obj}[${inlinedValueFromString(key)}]`
: `${obj}.${key}`;
var pathConcat =
(
path,
concatedPath,
) =>
path.length
? concatedPath.length
? path.concat(concatedPath)
: path
: concatedPath;
var pathToText =
(path) => {
let text = "";
for (
let idx = 0;
idx < path.length;
idx++
) {
const segment = path[idx];
text +=
typeof segment !== "string"
? `[${String(segment)}]`
: /^\d+$/.test(segment)
? `[${segment}]`
: segment === "[]"
? segment
: jsIdentRe.test(segment)
? text
? `.${segment}`
: segment
: `[${inlinedValueFromString(segment)}]`;
}
return text;
};
var stringTag = "string";
var numberTag = "number";
var bigintTag = "bigint";
var booleanTag = "boolean";
var symbolTag = "symbol";
var nullTag = "null";
var undefinedTag = "undefined";
var nanTag = "nan";
var functionTag = "function";
var instanceTag = "instance";
var arrayTag = "array";
var objectTag = "object";
var anyOfTag = "anyOf";
var neverTag = "never";
var unknownTag = "unknown";
var refTag = "ref";
var tagFlags = {
[unknownTag]: 1,
[stringTag]: 2,
[numberTag]: 4,
[booleanTag]: 8,
[undefinedTag]: 16,
[nullTag]: 32,
[objectTag]: 64,
[arrayTag]: 128,
[anyOfTag]: 256,
[refTag]: 512,
[bigintTag]: 1024,
[nanTag]: 2048,
[functionTag]: 4096,
[instanceTag]: 8192,
[neverTag]: 32768,
[symbolTag]: 16384,
};
var vendor = "sury";
var s = Symbol(vendor);
vendor + "";
var U = void 0;
var immutableEmptyArray = [];
var immutableEmptyObject =
Object.create(null);
var isSchemaObject = (obj) =>
typeof obj === objectTag &&
obj !== null &&
"~standard" in obj;
var isLiteral = (schema) =>
"const" in schema;
var isOptional = (schema) =>
schema.type === undefinedTag ||
(schema.type === anyOfTag &&
undefinedTag in schema.has);
var namedConstructor = (unknown2) => {
const ctor =
Object.getPrototypeOf(
unknown2,
)?.constructor;
return ctor !== Object && ctor?.name;
};
var stringifyLeaf = (unknown2) => {
const tagFlag =
tagFlags[typeof unknown2];
if (tagFlag & 16) return undefinedTag;
else if (tagFlag & 4160)
return unknown2 === null
? nullTag
: Array.isArray(unknown2)
? `Array(${unknown2.length})`
: namedConstructor(unknown2) ||
objectTag;
else if (tagFlag & 2)
return `"${unknown2}"`;
else if (tagFlag & 1024)
return `${unknown2}n`;
else return unknown2.toString();
};
var stringify = (unknown2) => {
if (
unknown2 !== null &&
typeof unknown2 === objectTag
) {
if (Array.isArray(unknown2)) {
const items = unknown2;
let body = "";
for (
let idx = 0;
idx < items.length;
idx++
) {
if (idx === 5) {
body += ", ...";
break;
}
body +=
(idx ? ", " : "") +
stringifyLeaf(items[idx]);
}
return `[${body}]`;
}
if (!namedConstructor(unknown2)) {
const dict2 = unknown2;
let body = "";
let count = 0;
for (const key in dict2) {
if (count++ === 5) {
body += "... ";
break;
}
body +=
key +
": " +
stringifyLeaf(dict2[key]) +
"; ";
}
return body ? `{ ${body}}` : "{}";
}
}
return stringifyLeaf(unknown2);
};
var inputExpression =
(
schema,
skipOverride,
) => {
if (schema.name) return schema.name;
else if (schema.const !== U)
return stringify(schema.const);
else if (
schema.expression &&
!skipOverride
)
return schema.expression(schema);
else if (schema.anyOf !== U) {
const anyOf = schema.anyOf;
const seen =
new Set();
let body = "";
for (
let idx = 0;
idx < anyOf.length;
idx++
) {
const expression =
inputExpression(
anyOf[idx],
);
if (!seen.has(expression)) {
seen.add(expression);
body +=
(body ? " | " : "") +
expression;
}
}
return body;
} else if (
schema.type === objectTag
) {
const properties =
schema.properties;
const additionalItems =
schema.additionalItems;
let body = "";
for (const location in properties)
body +=
location +
": " +
inputExpression(
properties[location],
) +
"; ";
if (
typeof additionalItems ===
objectTag
)
body +=
"[key: string]: " +
inputExpression(
additionalItems,
) +
"; ";
return body ? `{ ${body}}` : "{}";
} else if (
schema.type === arrayTag
) {
const additionalItems =
schema.additionalItems;
if (
typeof additionalItems ===
objectTag
) {
const item = additionalItems;
const itemName =
inputExpression(
item,
);
return (
(item.type === anyOfTag ||
item.bounds !== U ||
item.multipleOf !== U
? `(${itemName})`
: itemName) + "[]"
);
}
const items = schema.items;
let body = "";
for (
let idx = 0;
idx < items.length;
idx++
)
body +=
(idx ? ", " : "") +
inputExpression(
items[idx],
);
return `[${body}]`;
} else if (schema.format)
return schema.format;
else if (
schema.type === instanceTag
)
return schema.class.name;
else return schema.type;
};
var Schema = function () {};
var schemaPrototype =
Object.create(null);
Object.defineProperty(
schemaPrototype,
"with",
{
value(fn, ...args) {
return fn(this, ...args);
},
},
);
Schema.prototype = schemaPrototype;
var reversedKey = "r";
var SelfReverseSchema = function () {};
var selfReversePrototype =
Object.create(schemaPrototype);
Object.defineProperty(
selfReversePrototype,
reversedKey,
{
get() {
return this;
},
},
);
Object.defineProperty(
selfReversePrototype,
"sr",
{ value: true },
);
SelfReverseSchema.prototype =
selfReversePrototype;
var isOwnSchema = (value) => {
const proto =
typeof value === objectTag &&
value &&
Object.getPrototypeOf(value);
return (
proto === schemaPrototype ||
proto === selfReversePrototype
);
};
var panicNotSchema = () =>
panic("Expected a Sury schema");
var seq = 1;
var exnId = {};
var SuryError = class extends Error {
constructor(params) {
super();
Object.assign(this, params);
}
get message() {
return formatErrorMessage(this);
}
get _1() {
return this;
}
get RE_EXN_ID() {
return exnId;
}
};
Object.defineProperty(
SuryError.prototype,
"name",
{ value: "SuryError" },
);
Object.defineProperty(
SuryError.prototype,
"s",
{ value: s },
);
var getOrRethrow = (exn) => {
if (exn && exn.s === s) return exn;
throw exn;
};
var panic = (message) => {
throw new Error(`[Sury] ${message}`);
};
var formatErrorMessage = (error) =>
`${error.path.length ? `Failed at ${/* @__PURE__ */ pathToText(error.path)}: ` : ""}${error.reason}`;
var globalConfig = {
m: formatErrorMessage,
d: U,
a: "strip",
f: 0,
};
var valueOptions = {};
var configurableValueOptions = {
configurable: true,
};
var valKey = "value";
var baseSchema = (
tag,
selfReverse,
decoder,
) => {
const schema = new (
selfReverse
? SelfReverseSchema
: Schema
)();
schema.type = tag;
schema.seq = seq++;
schema.decoder = decoder;
return schema;
};
var noopDecoder = (input) => input;
var initSchema =
(
tag,
decoder,
init,
) => {
const schema = baseSchema(
tag,
true,
decoder,
);
return (init?.(schema), schema);
};
var unknown = baseSchema(
unknownTag,
true,
noopDecoder,
);
var copySchema = (schema) => {
const c = Object.assign(
new Schema(),
schema,
);
c.seq = seq++;
if (schema.content !== U)
setContent(c, schema.content);
if (schema.bc !== U)
setBytesCodec(c, schema.bc);
return c;
};
var copyTo = (from, to2) => {
const mut = copySchema(from);
mut.to = to2;
return mut;
};
var setContent = (schema, content) => {
valueOptions[valKey] = content;
Object.defineProperty(
schema,
"content",
valueOptions,
);
};
var setBytesCodec = (schema, codec) => {
valueOptions[valKey] = codec;
Object.defineProperty(
schema,
"bc",
valueOptions,
);
};
var updateOutput = (schema, fn) => {
const root = copySchema(schema);
let mut = root;
while (mut.to) {
const next = copySchema(mut.to);
mut.to = next;
mut = next;
}
fn(mut);
return root;
};
var setHas = (has, tag) => {
has[
tagFlags[tag] & 768
? unknownTag
: tag
] = true;
};
function _var() {
return this.i;
}
var _linkVar = function () {
return (this.b || this.prev).v();
};
function _notVarBeforeValidation() {
const val = this;
const v = B_varWithoutAllocation(
val.g,
);
val.cp = `let ${v}=${val.i};`;
val.i = v;
val.v = _var;
return v;
}
function _notVarAtParent() {
const val = this;
const parent = val.p;
if (parent.fz) {
val.v = _var;
return val.i;
}
const v = B_varWithoutAllocation(
val.g,
);
B_hoistDecl(parent, `${v}=${val.i}`);
val.v = _var;
val.i = v;
return v;
}
function _notVar() {
const val = this;
if (val.fz) {
val.v = _var;
val.i = `(${val.i})`;
return val.i;
}
const v = B_varWithoutAllocation(
val.g,
);
if (val.prev !== U) {
if (val.i === "")
val.cp = `let ${v};` + val.cp;
else val.cp += `let ${v}=${val.i};`;
} else
B_hoistDecl(
val,
val.i === ""
? v
: `${v}=${val.i}`,
);
val.v = _var;
val.i = v;
return v;
}
var operationArgVar = "i";
var failInvalidType = (input) => {
const em = input.e.errorMessage;
return B_invalidInputBuilder(
U,
U,
em &&
(input.e.format !== U &&
em.format !== U
? em.format
: em.type !== U
? em.type
: em._),
)(input);
};
var B_embed = (b, value) => (
b.g.t++,
B_embedPure(b, value)
);
var B_embedPure = (b, value) =>
`e[${b.g.e.push(value) - 1}]`;
var B_inlineConst = (b, schema) => {
const tagFlag = tagFlags[schema.type],
const_ = schema.const;
return tagFlag & 16
? "void 0"
: tagFlag & 2
? inlinedValueFromString(const_)
: tagFlag & 1024
? const_ + "n"
: tagFlag & 28672
? B_embedPure(b, schema.const)
: const_;
};
var B_varWithoutAllocation = (g) =>
`v${++g.v}`;
var B_hoistDecl = (owner, decl) => {
owner.hd += (owner.hd && ",") + decl;
};
var B_operationArg = (
schema,
expected,
flag,
defs,
) => {
return {
b: U,
p: U,
v: _var,
i: operationArgVar,
s: schema,
io: U,
e: expected,
prev: U,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathEmpty,
g: {
d: defs,
o: flag,
e: [],
v: -1,
t: 0,
},
o: U,
};
};
var B_throw = (errorDetails) => {
throw new SuryError(errorDetails);
};
var B_unsupportedDecode = (
b,
from,
target,
) =>
B_throw({
code: "unsupported_decode",
from,
to: target,
reason: `Can't decode ${/* @__PURE__ */ inputExpression(from)} -> ${/* @__PURE__ */ inputExpression(target)}. Define custom codec with S.to`,
path: b.path,
});
var B_failWithArg = (b, fn, arg) =>
`${B_embed(b, (a) => {
B_throw(fn(a));
})}(${arg})`;
var B_markThrow = (b) => {
b.g.t++;
};
var B_foreignDetails = (
input,
to2,
cause,
) => ({
code: "invalid_conversion",
from: input.s,
to: to2,
cause,
path: input.path,
reason:
cause instanceof Error
? ("" + cause).replace(
/^Error: /,
"",
)
: stringify(cause),
});
var B_errorOf = (input) => {
let to2 = input.e;
while (to2.to) to2 = to2.to;
return (e) =>
e && e.s === s
? e
: new SuryError(
B_foreignDetails(
input,
to2,
e,
),
);
};
var B_makeInvalidInputDetails = (
expected,
received,
path,
input,
unionErrors,
reasonOverride,
) => {
let reasonRef = reasonOverride;
if (reasonRef === U) {
const expectedExpression =
inputExpression(
expected,
);
const receivedExpression =
stringify(input);
reasonRef = `Expected ${expectedExpression}, received ${expectedExpression === receivedExpression ? "invalid " : ""}${receivedExpression}`;
}
if (unionErrors) {
const seenReasons =
new Set();
for (
let idx = 0;
idx < unionErrors.length;
idx++
) {
const caseError =
unionErrors[idx];
const line = `
- ${caseError.path.length ? `At ${/* @__PURE__ */ pathToText(caseError.path)}: ` : ""}${caseError.reason.split("\n").join("\n ")}`;
if (!seenReasons.has(line)) {
seenReasons.add(line);
reasonRef += line;
}
}
}
return {
code: "invalid_input",
expected,
received,
path,
reason: reasonRef,
unionErrors,
input,
};
};
var B_invalidInputBuilder =
(
expected,
extraPath = pathEmpty,
reasonOverride,
) =>
(input) => {
const path =
pathConcat(
input.path,
extraPath,
);
return (value) =>
B_makeInvalidInputDetails(
expected ?? input.e,
(input.prev || input).s,
path,
value,
U,
reasonOverride,
);
};
var B_failWithErrorMessage =
(key, defaultMessage) => (input) => {
const em = input.e.errorMessage;
const m =
em?.[key] ??
em?.["_"] ??
defaultMessage;
return m !== U
? B_invalidInputBuilder(
U,
U,
m,
)(input)
: failInvalidType(input);
};
var B_embedInvalidInput = (
input,
expected = input.e,
) =>
B_failWithArg(
input,
B_invalidInputBuilder(expected)(
input,
),
input.v(),
);
var B_emitChecks = (val, inputVar) => {
const checks = val.vc;
let out = "",
i = 0,
len = checks.length;
while (i < len) {
const head = checks[i],
fail = head.f;
let cond = head.c(inputVar);
i++;
while (
i < len &&
checks[i].f === fail
) {
cond +=
"&&" + checks[i].c(inputVar);
i++;
}
out += `${cond}||${B_failWithArg(val, fail(val), inputVar)};`;
}
return out;
};
var B_merge = (val, out) => {
let current = val,
code = "";
while (current !== U) {
const val2 = current;
current = val2.prev;
let currentCode = "";
if (val2.vc) {
if (
out &&
(!val2.t ||
(!val2.prev.t &&
val2.cp === ""))
) {
const inputVar = (
current || val2
).v();
const checks = val2.vc;
let hoisted = "";
for (
let i = 0;
i < checks.length;
i++
) {
const check = checks[i];
const condCode =
check.c(inputVar);
if (
check.f === failInvalidType
)
hoisted = hoisted
? `${hoisted}&&${condCode}`
: condCode;
else if (
val2.e.noValidation !== true
)
currentCode += `${condCode}||${B_failWithArg(val2, check.f(val2), inputVar)};`;
}
if (hoisted) {
out.c = out.c
? `${hoisted}&&${out.c}`
: hoisted;
out.h.unshift({
v: val2,
i: inputVar,
c: hoisted,
});
}
} else if (
val2.e.noValidation !== true
)
currentCode = B_emitChecks(
val2,
(current || val2).v(),
);
}
if (val2.hd)
currentCode += `let ${val2.hd};`;
val2.fz = true;
code = val2.cp + currentCode + code;
}
return code;
};
var B_linkVar = (val, nextVal) => {
const get = val.v.bind(val);
val.v = () => (
(nextVal.i = get()),
(nextVal.v = _var),
nextVal.i
);
};
var B_next = (
prev,
initial,
schema,
expected = prev.e,
) => {
return {
b: U,
p: U,
v: _notVar,
i: initial,
s: schema,
io: U,
e: expected,
prev,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: true,
path: prev.path,
g: prev.g,
o: U,
};
};
var B_refine = (
val,
schema = val.s,
checks,
expected = val.e,
) => {
const shouldLink = val.v !== _var;
const nextVal = {
b: U,
p: U,
v: shouldLink ? _linkVar : _var,
i: val.i,
s: schema,
io: U,
e: expected,
prev: val,
f: val.f,
d: val.d,
fv: U,
cp: "",
hd: "",
fz: U,
vc: checks,
u: U,
t: val.t,
path: val.path,
g: val.g,
o: U,
};
if (shouldLink)
B_linkVar(val, nextVal);
return nextVal;
};
var B_pushCheck = (val, check) => {
(val.vc ?? (val.vc = [])).push(check);
};
var B_markOutput = (val, valInput) => {
let outC;
const ir = valInput.e.inputRefiner;
if (ir) {
const c = ir(valInput);
if (c.length)
(
valInput.vc ??
(valInput.vc = [])
).push(...c);
}
const rf = val.e.refiner;
if (rf) {
const c = rf(val);
if (c.length) outC = c;
}
if (outC && val.f & 1) {
const v = val.v();
val.i = `${v}.then(${v}=>{${B_merge(B_refine(B_scope(val), U, outC))}return ${v}})`;
val.v = _notVar;
} else if (outC)
val = B_refine(val, U, outC);
val.io = true;
return val;
};
var B_hoistChildChecks = (
parent,
child,
key,
) => {
const checks = child.vc;
if (checks) {
const accessor = inlinedProperty(
"",
key,
parent.s.type === arrayTag,
);
for (
let i = 0;
i < checks.length;
i++
) {
const check = checks[i];
B_pushCheck(parent, {
c: (v) => check.c(v + accessor),
f: check.f,
});
}
child.vc = U;
}
};
var B_dynamicScope = (
from,
locationVar,
) => {
const schemaAdditionalItems =
from.s.additionalItems;
const expectedAdditionalItems =
from.e.additionalItems;
return {
b: U,
p: from,
v: _notVarBeforeValidation,
i: `${from.v()}[${locationVar}]`,
s:
schemaAdditionalItems !== U &&
typeof schemaAdditionalItems !==
"string"
? schemaAdditionalItems
: unknown,
io: U,
e:
expectedAdditionalItems !== U &&
typeof expectedAdditionalItems !==
"string"
? expectedAdditionalItems
: unknown,
prev: U,
f: from.f,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathEmpty,
g: from.g,
o: U,
};
};
var B_nextConst = (
from,
schema,
expected,
) =>
B_next(
from,
B_inlineConst(from, schema),
schema,
expected,
);
var B_nextVar = (
input,
schema = input.e,
expected = schema,
) => {
const output = B_next(
input,
B_varWithoutAllocation(input.g),
schema,
expected,
);
output.v = _var;
return output;
};
var B_nextVarOutput = (
input,
initial,
schema,
expected = schema,
) => {
const output = B_next(
input,
initial,
schema,
expected,
);
output.v = _var;
output.io = true;
return output;
};
var B_asyncVal = (from, initial) => {
const v = B_next(
from,
initial,
from.s,
);
v.f = 1;
return v;
};
var B_addObjectField = (
objectVal,
location,
val,
) => {
if (objectVal.s.type === arrayTag)
objectVal.s.items.push(val.s);
else {
if (!val.o)
objectVal.s.required.push(
location,
);
objectVal.s.properties[location] =
val.s;
}
if (val.f & 1) val.v();
objectVal.cp += B_merge(val);
objectVal.d[location] = val;
};
var B_addKey = (objVal, key, value) =>
`${objVal.v()}[${key}]=${value.i}`;
var B_scope = (val) => {
const shouldLink = val.v !== _var;
const nextVal = {
b: val,
p: U,
v: shouldLink ? _linkVar : _var,
i: val.i,
s: val.s,
io: val.io,
e: val.e,
prev: U,
f: 0,
d: val.d,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: false,
t: false,
path: val.path,
g: val.g,
o: U,
};
if (shouldLink)
B_linkVar(val, nextVal);
return nextVal;
};
var B_neverSlot = (input) =>
B_invalidOperation(
input,
`Nothing decodes ${/* @__PURE__ */ inputExpression(input.e)} -> ${/* @__PURE__ */ inputExpression(input.e.to)}. It is marked with S.never`,
);
var B_invalidOperation = (
val,
description,
) =>
B_throw({
code: "invalid_operation",
reason: description,
path: val.path,
});
var B_mergeWithCatch = (
val,
catchFn,
appendSafe,
pureSince,
) => {
const valCode = B_merge(val);
const pure =
pureSince !== U &&
val.g.t === pureSince;
if (
(valCode === "" || pure) &&
!(val.f & 1)
)
return appendSafe
? valCode + appendSafe()
: pure
? ""
: valCode;
const errorVar =
B_varWithoutAllocation(val.g);
B_markThrow(val);
const catchCode = `${catchFn(errorVar)};throw ${errorVar}`;
if (val.f & 1)
val.i = `${val.i}.catch(${errorVar}=>{${catchCode}})`;
return `try{${valCode}${appendSafe ? appendSafe() : ""}}catch(${errorVar}){${catchCode}}`;
};
var B_mergeWithPathPrepend = (
val,
parent,
locationVar,
appendSafe,
pureSince,
) =>
!val.path.length && locationVar === U
? B_merge(val)
: B_mergeWithCatch(
val,
(errorVar) => {
let segments = "";
for (
let idx = 0;
idx < parent.path.length;
idx++
) {
const segment =
parent.path[idx];
segments += `${typeof segment === "string" ? inlinedValueFromString(segment) : segment},`;
}
if (locationVar !== U)
segments += `${locationVar},`;
return `${errorVar}.path=[${segments}...${errorVar}.path]`;
},
appendSafe,
pureSince,
);
var noopOperation = (i) => i;
noopOperation["embedded"] =
immutableEmptyArray;
var int32FormatValidation = (
inputVar,
) =>
`${inputVar}<=2147483647&&${inputVar}>=-2147483648&&${inputVar}%1==0`;
var integerFormatValidation = (
inputVar,
) => `${inputVar}%1==0`;
var typeofCondCache = {};
var typeofCond = (tag) =>
typeofCondCache[tag] ||
(typeofCondCache[tag] = (inputVar) =>
`typeof ${inputVar}==="${tag}"`);
var nanCond = (inputVar) =>
`Number.isNaN(${inputVar})`;
var isArrayCond = (inputVar) =>
`Array.isArray(${inputVar})`;
var objectTagCond = (inputVar) =>
`${typeofCond(objectTag)(inputVar)}&&${inputVar}&&!${isArrayCond(inputVar)}`;
var numberTagCond = (
inputVar,
allowNaN,
) => {
const t =
typeofCond(numberTag)(inputVar);
return allowNaN
? t
: `${t}&&${inputVar}==${inputVar}`;
};
var instanceofCond = (
b,
class_,
inputVar,
) =>
`${inputVar} instanceof ${B_embed(b, class_)}`;
var typeofCheckCache = {};
var typeofCheck = (tag) =>
typeofCheckCache[tag] ||
(typeofCheckCache[tag] = {
c: typeofCond(tag),
f: failInvalidType,
});
var B_typeDecode = (
input,
tag,
inputTagFlag,
) =>
inputTagFlag & 1
? B_refine(input, input.e, [
typeofCheck(tag),
])
: inputTagFlag & tagFlags[tag]
? input
: B_unsupportedDecode(
input,
input.s,
input.e,
);
var numberDecoder = (input) => {
const inputTagFlag =
tagFlags[input.s.type];
const expectedFormat = input.e.format;
if (inputTagFlag & 1) {
if (expectedFormat === "int32")
return B_refine(input, input.e, [
typeofCheck(numberTag),
{
c: int32FormatValidation,
f: failInvalidType,
},
]);
if (expectedFormat === "integer")
return B_refine(input, input.e, [
typeofCheck(numberTag),
{
c: integerFormatValidation,
f: failInvalidType,
},
]);
return B_refine(input, input.e, [
{
c: (v) =>
numberTagCond(
v,
!!(input.g.o & 2),
),
f: failInvalidType,
},
]);
} else if (inputTagFlag & 2) {
const output = B_nextVar(input);
const inputVar = input.v();
output.cp = `let ${output.i}=+${inputVar};`;
output.vc = [
{
c: (_inputVar) =>
`${expectedFormat === "int32" ? int32FormatValidation(output.i) : expectedFormat === "integer" ? integerFormatValidation(output.i) : `${output.i}==${output.i}`}&&(${output.i}||${inputVar}.trim())`,
f: failInvalidType,
},
];
return output;
} else if (
inputTagFlag & 2048 &&
expectedFormat !== "int32" &&
expectedFormat !== "integer" &&
input.g.o & 2
)
return B_refine(input, input.e);
else if (inputTagFlag & 4) {
if (
input.s.format !==
expectedFormat &&
expectedFormat === "int32"
)
return B_refine(input, input.e, [
input.s.format === U
? {
c: int32FormatValidation,
f: failInvalidType,
}
: {
c: (inputVar) =>
`${inputVar}<=2147483647&&${inputVar}>=-2147483648`,
f: failInvalidType,
},
]);
if (
expectedFormat === "integer" &&
input.s.format === U
)
return B_refine(input, input.e, [
{
c: integerFormatValidation,
f: failInvalidType,
},
]);
}
return B_typeDecode(
input,
numberTag,
inputTagFlag,
);
};
var float = initSchema(
numberTag,
numberDecoder,
);
var inputToString = (
input,
schema = string,
) =>
B_next(
input,
`""+${input.i}`,
schema,
);
var stringDecoderFn = (input) => {
const inputTagFlag =
tagFlags[input.s.type];
if (
inputTagFlag & 3132 &&
isLiteral(input.s)
) {
const const_ = "" + input.s.const;
const schema = baseSchema(
stringTag,
false,
input.s.decoder,
);
schema.const = const_;
return B_next(
input,
`"${const_}"`,
schema,
);
}
if (inputTagFlag & 1036)
return inputToString(
input,
input.e,
);
return B_typeDecode(
input,
stringTag,
inputTagFlag,
);
};
var string = initSchema(
stringTag,
stringDecoderFn,
);
var literalDecoder = (input) => {
const expectedSchema = input.e;
if (
expectedSchema.noValidation &&
!input.u
)
return B_nextConst(
input,
expectedSchema,
);
else if (isLiteral(input.s)) {
if (
input.s.const ===
expectedSchema.const
)
return input;
else
return B_nextConst(
input,
expectedSchema,
);
} else {
const schemaTagFlag =
tagFlags[expectedSchema.type];
if (
tagFlags[input.s.type] & 2 &&
schemaTagFlag & 3132
) {
const stringConstSchema =
baseSchema(
stringTag,
false,
literalDecoder,
);
stringConstSchema.const =
"" + expectedSchema.const;
const stringConstVal =
B_nextConst(
input,
stringConstSchema,
stringConstSchema,
);
stringConstVal.vc = [
{
c: (inputVar) =>
`${inputVar}==="${stringConstSchema.const}"`,
f: failInvalidType,
},
];
return B_nextConst(
stringConstVal,
expectedSchema,
expectedSchema,
);
} else if (schemaTagFlag & 2048)
return B_refine(
input,
expectedSchema,
[
{
c: nanCond,
f: failInvalidType,
},
],
);
else
return B_refine(
input,
expectedSchema,
[
{
c: (inputVar) =>
`${inputVar}===${B_inlineConst(input, expectedSchema)}`,
f: failInvalidType,
},
],
);
}
};
var unit = initSchema(
undefinedTag,
literalDecoder,
(s2) => {
s2.const = U;
},
);
var nullLiteral =
initSchema(
nullTag,
literalDecoder,
(s2) => {
s2.const = null;
},
);
var nan = initSchema(
nanTag,
literalDecoder,
(s2) => {
s2.const = NaN;
},
);
var Literal_parse = (value) => {
if (value === null)
return nullLiteral;
else {
const tag = typeof value;
if (tag === undefinedTag)
return unit;
else if (
tag === numberTag &&
Number.isNaN(value)
)
return nan;
else if (tag === objectTag) {
const s2 = baseSchema(
instanceTag,
true,
literalDecoder,
);
s2.class = value["constructor"];
s2.const = value;
return s2;
} else {
const s2 = baseSchema(
tag,
true,
literalDecoder,
);
s2.const = value;
return s2;
}
}
};
var parse = (input) => {
let result = input;
let appliedEncoderRef = U;
let loopCount = 0;
while (!result.io || result.e.to) {
const appliedEncoder =
appliedEncoderRef;
appliedEncoderRef = U;
const loopInput = result;
if (++loopCount > 50)
panic("Loop count exceeded 50");
const defs = loopInput.e["$defs"];
if (defs)
loopInput.g.d
? Object.assign(
loopInput.g.d,
defs,
)
: (loopInput.g.d = defs);
if (loopInput.f & 1) {
const operationInputVar =
loopInput.v();
const operationInput =
B_scope(loopInput);
const operationOutput = parse(
operationInput,
);
const operationCode = B_merge(
operationOutput,
);
result =
operationInput.i !==
operationOutput.i ||
operationCode !== ""
? B_next(
loopInput,
`${operationInputVar}.then(${operationInputVar}=>{${operationCode}return ${operationOutput.i}})`,
operationOutput.s,
operationOutput.e,
)
: B_refine(
loopInput,
operationOutput.s,
U,
operationOutput.e,
);
result.f |= 1;
result.io = true;
} else if (loopInput.io) {
const to2 = loopInput.e.to;
result = loopInput.e.parser
? loopInput.e.parser(loopInput)
: B_refine(result, U, U, to2);
} else {
const maybeEncoder =
loopInput.s.encoder;
if (
maybeEncoder &&
maybeEncoder !==
appliedEncoder &&
loopInput.s !== loopInput.e &&
loopInput.e.type !==
unknownTag &&
!(
loopInput.e.noValidation &&
(loopInput.e.isJson ||
loopInput.e.type ===
undefinedTag)
)
)
result = maybeEncoder(
loopInput,
loopInput.e,
);
if (loopInput !== result)
appliedEncoderRef =
maybeEncoder;
else {
result =
loopInput.e.decoder(
loopInput,
);
if (!result.io)
result = B_markOutput(
result,
result,
);
}
}
}
return result;
};
var parseDynamic = (input) => {
try {
return parse(input);
} catch (exn) {
const error = getOrRethrow(exn);
error.path =
pathConcat(
input.p
? input.p.path
: pathEmpty,
pathConcat(
pathConcat(
input.path,
pathDynamic,
),
error.path,
),
);
throw error;
}
};
var throwTail = (
input,
code,
out,
isAsync,
flag,
hasDefs,
) => {
if (flag & 1024) {
const errorOf = B_errorOf(input);
const issues = B_embedPure(
input,
(e2) => {
const error = errorOf(e2);
return {
issues: [
{
message: error.reason,
path: error.path.length
? error.path
: U,
},
],
};
},
);
const v = isAsync
? B_varWithoutAllocation(input.g)
: "";
const body = isAsync
? `${code}return ${out}.then(${v}=>({value:${v}}),${issues})`
: `${code}return {value:${out}}`;
if (!input.g.t) return body;
const e = B_varWithoutAllocation(
input.g,
);
return `try{${body}}catch(${e}){return ${isAsync ? `Promise.resolve(${issues}(${e}))` : `${issues}(${e})`}}`;
}
return code === "" &&
out === operationArgVar &&
!(flag & 1)
? U
: `${code}return ${flag & 1 && !isAsync && !hasDefs ? `Promise.resolve(${out})` : out}`;
};
var emitTail = throwTail;
var compileDecoder = (
schema,
expected,
flag,
defs,
node,
) => {
const input = B_operationArg(
isLiteral(schema)
? unknown
: schema,
expected,
flag,
defs,
);
const output = parse(input);
const code = B_merge(output);
const isAsync = !!(output.f & 1);
if (node) {
node.y = isAsync;
node.t = output.t === true;
}
const body = emitTail(
input,
code,
output.i,
isAsync,
flag,
!!defs,
);
if (!body) return noopOperation;
const fn = new Function(
"e",
"s",
`return ${operationArgVar}=>{${body}}`,
)(input.g.e, s);
fn.embedded = input.g.e;
return fn;
};
var getOutputSchema = (schema) => {
while (schema.to) schema = schema.to;
return schema;
};
var reverseSwap = (mut, a, b) => {
const previous = mut[a];
mut[b] === U
? delete mut[a]
: (mut[a] = mut[b]);
previous === U
? delete mut[b]
: (mut[b] = previous);
};
var reverseDict = (dict2) => {
const reversed =
Object.create(null);
for (const key in dict2)
reversed[key] =
reverse(
dict2[key],
);
return reversed;
};
Object.defineProperty(
schemaPrototype,
reversedKey,
{
get() {
const schema = this;
let reversedHead = U;
let current = schema;
while (current) {
const mut = copySchema(current);
const next = mut.to;
reversedHead
? (mut.to = reversedHead)
: delete mut.to;
const record = mut;
reverseSwap(
record,
"parser",
"serializer",
);
reverseSwap(
record,
"refiner",
"inputRefiner",
);
next && next.opens !== U
? (mut.opens = !next.opens)
: delete mut.opens;
delete record["default"];
delete record["examples"];
if (mut.items)
mut.items =
mut.items.map(reverse);
if (mut.properties)
mut.properties = reverseDict(
mut.properties,
);
if (
typeof mut.additionalItems ===
objectTag
)
mut.additionalItems =
reverse(
mut.additionalItems,
);
if (mut.anyOf) {
const anyOf = mut.anyOf;
const has = {};
const newAnyOf = [];
for (
let idx = 0;
idx < anyOf.length;
idx++
) {
const s2 = anyOf[idx];
const reversed =
reverse(
s2,
);
newAnyOf.push(reversed);
setHas(has, reversed.type);
}
mut.has = has;
mut.anyOf = newAnyOf;
}
if (mut["$defs"])
mut["$defs"] = reverseDict(
mut["$defs"],
);
reversedHead = mut;
current = next;
}
const r = reversedHead;
valueOptions[valKey] = r;
Object.defineProperty(
schema,
reversedKey,
valueOptions,
);
valueOptions[valKey] = schema;
Object.defineProperty(
r,
reversedKey,
valueOptions,
);
return r;
},
},
);
var reverse =
(schema) =>
schema.r;
var memoKey = "c";
var addOpNode = (schema, a, f, v) => {
const created = {
a,
f,
v,
n: schema[memoKey],
};
configurableValueOptions[valKey] =
created;
Object.defineProperty(
schema,
memoKey,
configurableValueOptions,
);
return created;
};
var compileChain = (
cacheTarget,
args,
flag,
) => {
let schema = args[args.length - 1];
for (
let i = args.length - 2;
i >= 0;
i--
) {
const to2 = schema;
schema = updateOutput(
args[i],
(mut) => {
mut.to = to2;
if (
mut.content !== U &&
mut.opens === U
)
mut.opens = true;
},
);
}
const f = compileDecoder(
flag & 8 ? unknown : schema,
schema,
flag,
U,
);
addOpNode(cacheTarget, args, flag, f);
return f;
};
var getOp = (
opFlag,
n,
a0,
a1,
a2,
a3,
) => {
const flag = opFlag | globalConfig.f;
let cacheTarget = a0;
let seq2 = a0.seq;
if (n > 1) {
if (a1.seq > seq2)
((seq2 = a1.seq),
(cacheTarget = a1));
if (n > 2) {
if (a2.seq > seq2)
((seq2 = a2.seq),
(cacheTarget = a2));
if (n > 3 && a3.seq > seq2)
cacheTarget = a3;
}
}
let node = cacheTarget[memoKey];
while (node) {
const a = node.a;
if (
node.f === flag &&
a.length === n &&
a[0] === a0 &&
(n < 2 || a[1] === a1) &&
(n < 3 || a[2] === a2) &&
(n < 4 || a[3] === a3)
)
return node.v;
node = node.n;
}
return compileChain(
cacheTarget,
[a0, a1, a2, a3].slice(0, n),
flag,
);
};
var nestedLoc =
"BS_PRIVATE_NESTED_SOME_NONE";
var never_ = initSchema(
neverTag,
(input) => {
const output = B_refine(
input,
never_,
U,
never_,
);
output.cp =
B_embedInvalidInput(input) + ";";
return output;
},
);
var instanceDecoder = (input) => {
const inputTagFlag =
tagFlags[input.s.type];
return inputTagFlag & 1
? B_refine(input, input.e, [
{
c: (v) =>
instanceofCond(
input,
input.e.class,
v,
),
f: failInvalidType,
},
])
: inputTagFlag & 8192 &&
input.s.class === input.e.class
? input
: B_unsupportedDecode(
input,
input.s,
input.e,
);
};
var typeCheckCond = (
input,
schema,
inputVar,
) => {
const tagFlag = tagFlags[schema.type];
if (tagFlag & 64)
return objectTagCond(inputVar);
if (tagFlag & 128)
return isArrayCond(inputVar);
if (tagFlag & 8192)
return instanceofCond(
input,
schema.class,
inputVar,
);
if (tagFlag & 4)
return numberTagCond(
inputVar,
!!(input.g.o & 2),
);
if (tagFlag & 2048)
return nanCond(inputVar);
if (tagFlag & 48)
return `${inputVar}===${B_inlineConst(input, schema)}`;
if (tagFlag & 17418)
return schema.format === "env"
? `(typeof ${inputVar}==="string"||${inputVar}===void 0)`
: typeofCond(schema.type)(
inputVar,
);
return "";
};
var isItemSchema = (x) =>
x !== U && typeof x !== "string";
var B_unrecognizedKeys = (
input,
keys,
keyVar,
decl,
) => {
const fail = B_failWithArg(
input,
(key) => ({
code: "unrecognized_key",
path: input.path,
reason: `Unrecognized key ${stringify(key)}`,
key,
}),
keyVar,
);
let cond = "";
for (
let idx = 0;
idx < keys.length;
idx++
) {
if (idx) cond += "&&";
cond += `${keyVar}!==${inlinedValueFromString(keys[idx])}`;
}
return (
`for(${decl}${keyVar} in ${input.v()})` +
(cond ? `if(${cond})` : "") +
fail +
";"
);
};
var B_fused = (
input,
expectedSchema,
item,
) => {
const to2 = expectedSchema.to;
return to2 !== U && to2.fz !== U
? to2.fz(
input,
expectedSchema,
item,
)
: U;
};
var B_narrowJsonSourcedJsonString = (
itemInput,
) => {
if (
itemInput.s.isJson &&
itemInput.e.format === "json"
)
itemInput.s = unknown;
};
var B_makeContainerVal = (
prev,
schema,
) => ({
b: U,
p: U,
v: _notVar,
i: "",
s: schema,
io: U,
e: prev.e,
prev,
f: 0,
d: Object.create(
null,
),
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: true,
path: prev.path,
g: prev.g,
o: U,
});
var makeObjectVal = (prev) =>
B_makeContainerVal(prev, {
type: objectTag,
required: [],
properties:
Object.create(
null,
),
additionalItems: "strict",
decoder: objectDecoder,
});
var makeArrayVal = (prev) =>
B_makeContainerVal(prev, {
type: arrayTag,
items: [],
additionalItems: "strict",
decoder: arrayDecoder,
});
var completeObjectVal = (objectVal) => {
const isArray =
objectVal.s.type === arrayTag;
let inline = "";
let promiseAllContent = "";
let optionalSettingCode = U;
const keys = Object.keys(objectVal.d);
for (
let idx = 0;
idx < keys.length;
idx++
) {
const key = keys[idx];
const val = objectVal.d[key];
if (val.f & 1)
promiseAllContent += val.i + ",";
if (val.o) {
const existingFn =
optionalSettingCode;
optionalSettingCode = (
objectVar,
) => {
return (
(existingFn === U
? ""
: existingFn(objectVar)) +
(key === "__proto__"
? `if(${val.v()}!==void 0){${objectVar}={...${objectVar},["__proto__"]:${val.i}}}`
: `if(${val.v()}!==void 0){${inlinedProperty(objectVar, key, isArray)}=${val.i}}`)
);
};
} else
inline =
inline +
(isArray
? `${val.i}`
: `${inlinedObjectKey(key)}:${val.i}`) +
",";
}
objectVal.i = isArray
? "[" + inline.slice(0, -1) + "]"
: "{" + inline.slice(0, -1) + "}";
if (promiseAllContent) {
promiseAllContent =
promiseAllContent.slice(0, -1);
const operationInput =
B_scope(objectVal);
operationInput.io = true;
const operationOutput = parse(
operationInput,
);
let operationCode = B_merge(
operationOutput,
);
let result = operationOutput.i;
if (optionalSettingCode !== U) {
const objectVar =
B_varWithoutAllocation(
objectVal.g,
);
operationCode =
operationCode +
`let ${objectVar}=${result};` +
optionalSettingCode(objectVar);
result = objectVar;
}
if (
operationCode === "" &&
promiseAllContent === result
)
objectVal.i = result;
else
objectVal.i = `Promise.all([${promiseAllContent}]).then(([${promiseAllContent}])=>{${operationCode}return ${result}})`;
objectVal.f |= 1;
objectVal.s = operationOutput.s;
objectVal.e = operationOutput.e;
objectVal.io = true;
return objectVal;
} else if (optionalSettingCode === U)
return objectVal;
else {
const code = optionalSettingCode(
objectVal.v(),
);
const output = B_refine(objectVal);
output.cp = output.cp + code;
return output;
}
};
var arrayFactory = (item) => {
const mut = baseSchema(
arrayTag,
!!item.sr,
arrayDecoder,
);
mut.additionalItems = item;
mut.items = immutableEmptyArray;
return mut;
};
var array = (
item,
) =>
arrayFactory(
definitionToSchema(
item,
),
);
var arrayDecoder = (unknownInput) => {
const isUnion = unknownInput.u;
const expectedSchema = unknownInput.e;
const unknownInputTagFlag =
tagFlags[unknownInput.s.type];
const expectedItems =
expectedSchema.items;
const expectedLength =
expectedItems.length;
let input;
if (unknownInputTagFlag & 129) {
const isArrayInput =
unknownInputTagFlag & 128;
let schema;
if (!isArrayInput)
schema = arrayFactory(unknown);
else schema = unknownInput.s;
const checks = [];
if (!isArrayInput)
checks.push({
c: isArrayCond,
f: failInvalidType,
});
const schemaAdditionalItems =
schema.additionalItems;
if (
!(isItemSchema(
schemaAdditionalItems,
)
? false
: schema.items.length ===
expectedLength)
) {
const expectedAdditionalItems2 =
expectedSchema.additionalItems;
if (
expectedAdditionalItems2 ===
"strict"
)
checks.push({
c: (inputVar) =>
`${inputVar}.length===${expectedLength}`,
f: failInvalidType,
});
else if (
expectedAdditionalItems2 ===
"strip"
)
checks.push({
c: (inputVar) =>
`${inputVar}.length>=${expectedLength}`,
f: failInvalidType,
});
}
input = B_refine(
unknownInput,
schema,
checks.length ? checks : U,
);
} else
input = B_unsupportedDecode(
unknownInput,
unknownInput.s,
expectedSchema,
);
let output;
const expectedAdditionalItems =
expectedSchema.additionalItems;
if (
isItemSchema(
expectedAdditionalItems,
)
) {
const itemSchema =
expectedAdditionalItems;
if (itemSchema === unknown)
output = input;
else {
if (expectedLength === 0) {
const fused = B_fused(
input,
expectedSchema,
itemSchema,
);
if (fused !== U)
return B_markOutput(
B_refine(input, fused),
input,
);
}
const inputVar = input.v();
const iteratorVar =
B_varWithoutAllocation(input.g);
const raiseCountBefore =
input.g.t;
const itemInput = B_dynamicScope(
input,
iteratorVar,
);
B_narrowJsonSourcedJsonString(
itemInput,
);
const itemOutput =
parseDynamic(itemInput);
const hasTransform = itemOutput.t;
const output2 = hasTransform
? B_next(
input,
`new Array(${inputVar}.length)`,
arrayFactory(itemOutput.s),
)
: B_refine(
input,
expectedSchema,
);
const itemCode =
B_mergeWithPathPrepend(
itemOutput,
input,
iteratorVar,
hasTransform
? () =>
B_addKey(
output2,
iteratorVar,
itemOutput,
)
: U,
hasTransform
? U
: raiseCountBefore,
);
if (
hasTransform ||
itemCode !== ""
)
output2.cp =
output2.cp +
`for(let ${iteratorVar}=${expectedLength};${iteratorVar}<${inputVar}.length;++${iteratorVar}){${itemCode}}`;
if (itemOutput.f & 1)
output = B_asyncVal(
output2,
`Promise.all(${output2.i})`,
);
else output = output2;
}
} else {
const objectVal =
makeArrayVal(input);
const fused = B_fused(
input,
expectedSchema,
);
const ai =
expectedSchema.additionalItems;
let shouldRecreateInput =
fused === U &&
ai !== "strict" &&
(ai !== "strip" ||
isItemSchema(
input.s.additionalItems,
) ||
input.s.items.length !==
expectedLength);
for (
let idx = 0;
idx < expectedLength;
idx++
) {
const schema = expectedItems[idx];
const key = String(idx);
const itemInput = valGet(
input,
key,
);
itemInput.e = schema;
itemInput.io = false;
itemInput.u = isUnion;
if (
fused !== U &&
!(isUnion && isLiteral(schema))
) {
B_addObjectField(
objectVal,
key,
itemInput,
);
continue;
}
B_narrowJsonSourcedJsonString(
itemInput,
);
const itemOutput =
parse(itemInput);
if (isUnion && isLiteral(schema))
B_hoistChildChecks(
input,
itemOutput,
key,
);
B_addObjectField(
objectVal,
key,
itemOutput,
);
if (!shouldRecreateInput)
shouldRecreateInput =
itemOutput.t;
}
if (shouldRecreateInput)
output =
completeObjectVal(objectVal);
else {
const o = B_refine(
input,
fused || expectedSchema,
);
o.cp = objectVal.cp;
o.d = objectVal.d;
output = o;
}
}
return B_markOutput(output, input);
};
var objectTypeCheck = {
c: objectTagCond,
f: failInvalidType,
};
var objectDecoder = (unknownInput) => {
const isUnion = unknownInput.u;
const expectedSchema = unknownInput.e;
const unknownInputTagFlag =
tagFlags[unknownInput.s.type];
let input;
if (unknownInputTagFlag & 65) {
const isObjectInput =
unknownInputTagFlag & 64;
let schema;
if (!isObjectInput) {
const mut = baseSchema(
objectTag,
false,
objectDecoder,
);
mut.properties =
immutableEmptyObject;
mut.additionalItems = unknown;
schema = mut;
} else schema = unknownInput.s;
input = isObjectInput
? B_refine(unknownInput, schema)
: B_refine(unknownInput, schema, [
objectTypeCheck,
]);
} else
input = B_unsupportedDecode(
unknownInput,
unknownInput.s,
expectedSchema,
);
const expectedAdditionalItems =
expectedSchema.additionalItems;
const dictItem = isItemSchema(
expectedAdditionalItems,
)
? expectedAdditionalItems
: U;
const inputAdditionalItems =
input.s.additionalItems;
const sourceIsDict = isItemSchema(
inputAdditionalItems,
);
let output;
if (
dictItem !== U &&
dictItem === unknown
)
output = input;
else if (
dictItem !== U &&
sourceIsDict
) {
const fused = B_fused(
input,
expectedSchema,
dictItem,
);
if (fused !== U)
return B_markOutput(
B_refine(input, fused),
input,
);
const inputVar = input.v();
const keyVar =
B_varWithoutAllocation(input.g);
const raiseCountBefore = input.g.t;
const itemInput = B_dynamicScope(
input,
keyVar,
);
B_narrowJsonSourcedJsonString(
itemInput,
);
const itemOutput =
parseDynamic(itemInput);
const hasTransform = itemOutput.t;
const output2 = hasTransform
? B_next(
input,
"{}",
dictFactory(itemOutput.s),
)
: B_refine(input, expectedSchema);
const itemCode =
B_mergeWithPathPrepend(
itemOutput,
input,
keyVar,
hasTransform
? () =>
B_addKey(
output2,
keyVar,
itemOutput,
)
: U,
hasTransform
? U
: raiseCountBefore,
);
if (hasTransform || itemCode !== "")
output2.cp =
output2.cp +
`for(let ${keyVar} in ${inputVar}){${itemCode}}`;
if (itemOutput.f & 1) {
const resolveVar =
B_varWithoutAllocation(
output2.g,
);
const rejectVar =
B_varWithoutAllocation(
output2.g,
);
const asyncParseResultVar =
B_varWithoutAllocation(
output2.g,
);
const counterVar =
B_varWithoutAllocation(
output2.g,
);
const outputVar = output2.v();
output = B_asyncVal(
output2,
`new Promise((${resolveVar},${rejectVar})=>{let ${counterVar}=Object.keys(${outputVar}).length;if(!${counterVar}){${resolveVar}(${outputVar})}for(let ${keyVar} in ${outputVar}){${outputVar}[${keyVar}].then(${asyncParseResultVar}=>{${outputVar}[${keyVar}]=${asyncParseResultVar};if(${counterVar}--===1){${resolveVar}(${outputVar})}},${rejectVar})}})`,
);
} else output = output2;
} else if (dictItem !== U) {
const itemSchema = dictItem;
const objectVal =
makeObjectVal(input);
const keys = Object.keys(
input.s.properties,
);
for (
let idx = 0;
idx < keys.length;
idx++
) {
const key = keys[idx];
const itemInput = valGet(
input,
key,
);
const source = itemInput.s;
const absent =
source.type === anyOfTag &&
source.has[undefinedTag] &&
!(
tagFlags[itemSchema.type] &
817
) &&
itemSchema.format !== "json";
if (absent) {
const target =
copySchema(source);
target.anyOf = source.anyOf.map(
(variant) =>
variant.type ===
undefinedTag
? variant
: updateOutput(
variant,
(mut) => {
mut.to = itemSchema;
},
),
);
target.perVariant = true;
itemInput.e = target;
} else itemInput.e = itemSchema;
itemInput.io = false;
itemInput.u = isUnion;
B_narrowJsonSourcedJsonString(
itemInput,
);
const itemOutput =
parse(itemInput);
if (absent) itemOutput.o = true;
B_addObjectField(
objectVal,
key,
itemOutput,
);
}
output =
completeObjectVal(objectVal);
} else {
const properties =
expectedSchema.properties;
const keys =
Object.keys(properties);
const keysCount = keys.length;
const objectVal =
makeObjectVal(input);
const ai =
expectedSchema.additionalItems;
const fused = B_fused(
input,
expectedSchema,
);
let shouldRecreateInput =
fused === U &&
ai !== "strict" &&
(ai !== "strip" ||
sourceIsDict ||
Object.keys(input.s.properties)
.length !== keysCount);
const isJsonParent =
isItemSchema(
inputAdditionalItems,
) && inputAdditionalItems.isJson;
for (
let idx = 0;
idx < keysCount;
idx++
) {
const key = keys[idx];
const schema = properties[key];
const itemInput = valGet(
input,
key,
);
itemInput.e = schema;
itemInput.io = false;
itemInput.u = isUnion;
if (
isJsonParent &&
schema.type === anyOfTag &&
schema.has[undefinedTag]
)
itemInput.i = `(${itemInput.i}??null)`;
if (
fused !== U &&
!(isUnion && isLiteral(schema))
) {
B_addObjectField(
objectVal,
key,
itemInput,
);
continue;
}
B_narrowJsonSourcedJsonString(
itemInput,
);
const itemOutput =
parse(itemInput);
if (isUnion && isLiteral(schema))
B_hoistChildChecks(
input,
itemOutput,
key,
);
B_addObjectField(
objectVal,
key,
itemOutput,
);
if (!shouldRecreateInput)
shouldRecreateInput =
itemOutput.t;
}
if (
ai === "strict" &&
isItemSchema(
inputAdditionalItems,
) &&
fused === U
) {
const keyVar =
B_varWithoutAllocation(
objectVal.g,
);
B_hoistDecl(input, keyVar);
objectVal.cp +=
B_unrecognizedKeys(
input,
keys,
keyVar,
"",
);
}
if (shouldRecreateInput)
output =
completeObjectVal(objectVal);
else {
const o = B_refine(
input,
fused || expectedSchema,
);
o.cp = objectVal.cp;
o.d = objectVal.d;
output = o;
}
}
return B_markOutput(output, input);
};
var dictFactory = (item) => {
const mut = baseSchema(
objectTag,
!!item.sr,
objectDecoder,
);
mut.properties = immutableEmptyObject;
mut.additionalItems = item;
return mut;
};
var definitionToSchema =
(
definition,
) =>
isSchemaObject(definition)
? definition
: traverseDefinition(
definition,
(node) =>
isSchemaObject(node)
? node
: U,
);
var traverseDefinition = (
definition,
onNode,
) => {
if (
typeof definition === objectTag &&
definition !== null
) {
const s2 = onNode(definition);
if (s2 !== U) return s2;
else if (
Array.isArray(definition)
) {
const node = definition;
for (
let idx = 0;
idx < node.length;
idx++
)
node[idx] = traverseDefinition(
node[idx],
onNode,
);
const items = node;
const mut = baseSchema(
arrayTag,
false,
arrayDecoder,
);
mut.items = items;
mut.additionalItems = "strict";
return mut;
} else {
const proto =
Object.getPrototypeOf(
definition,
);
if (
proto !== null &&
proto !== Object.prototype
) {
const mut = baseSchema(
instanceTag,
true,
literalDecoder,
);
mut.class =
definition["constructor"];
mut.const = definition;
return mut;
} else {
const node = definition;
const fieldNames =
Object.keys(node);
const length2 =
fieldNames.length;
for (
let idx = 0;
idx < length2;
idx++
) {
const location =
fieldNames[idx];
node[location] =
traverseDefinition(
node[location],
onNode,
);
}
const mut = baseSchema(
objectTag,
false,
objectDecoder,
);
mut.required = fieldNames;
mut.properties = node;
mut.additionalItems =
globalConfig.a;
return mut;
}
}
} else
return Literal_parse(definition);
};
var missingKeyEncoder = (
input,
target,
) => {
const item = input.s.anyOf[0];
const v = input.v();
const presentIn = B_scope(input);
presentIn.io = false;
presentIn.s = item;
presentIn.e = target;
presentIn.u = true;
const presentOut = parse(presentIn);
const presentCode =
B_merge(presentOut);
const presentAssign =
presentOut.i === v
? ""
: `${v}=${presentOut.i};`;
const absentCode2 = isOptional(target)
? ""
: B_embedInvalidInput(
input,
target,
);
const output = B_nextVarOutput(
input,
v,
getOutputSchema(target),
target,
);
const presentBody =
presentCode + presentAssign;
output.cp =
presentBody === ""
? absentCode2 === ""
? ""
: `${v}!==void 0||${absentCode2};`
: absentCode2 === ""
? `if(${v}!==void 0){${presentBody}}`
: `if(${v}!==void 0){${presentBody}}else{${absentCode2}}`;
return output;
};
var wrapDictMissingKeyLight = (s2) => {
const mut = baseSchema(
anyOfTag,
false,
noopDecoder,
);
mut.anyOf = [s2, unit];
mut.has = { [undefinedTag]: true };
setHas(mut.has, s2.type);
mut.encoder = missingKeyEncoder;
mut.perVariant = true;
return mut;
};
var valGet = (parent, location) => {
const vals =
parent.d ??
(parent.d =
Object.create(
null,
));
const existing = vals[location];
if (existing !== U)
return B_scope(existing);
else {
let locationSchema;
if (parent.s.type === objectTag)
locationSchema =
parent.s.properties[location];
else
locationSchema =
parent.s.items[
Number(location)
];
let schema;
if (locationSchema !== U)
schema = locationSchema;
else {
const additionalItems =
parent.s.additionalItems;
if (
isItemSchema(additionalItems)
) {
const s2 = additionalItems;
if (
parent.s.type === objectTag &&
s2.type !== unknownTag &&
!(tagFlags[s2.type] & 512) &&
!isOptional(s2)
)
schema =
wrapDictMissingKeyLight(s2);
else schema = s2;
} else
schema = B_unsupportedDecode(
parent,
parent.s,
parent.e,
);
}
const accessor = inlinedProperty(
"",
location,
parent.s.type === arrayTag,
);
const item = {
b: U,
p: parent,
v: _notVarAtParent,
i: isLiteral(schema)
? B_inlineConst(parent, schema)
: parent.s.type === objectTag &&
location in Object.prototype
? `(Object.hasOwn(${parent.v()},${inlinedValueFromString(location)})?${parent.v()}${accessor}:void 0)`
: `${parent.v()}${accessor}`,
s: schema,
io: U,
e: schema,
prev: U,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathConcat(
parent.path,
[location],
),
g: parent.g,
o: U,
};
vals[location] = item;
return item;
}
};
var unionRuntimeSame = (a, b) =>
a.type === b.type &&
a.class === b.class;
var unionSameType = (a, b) =>
a === b ||
(unionRuntimeSame(a, b) &&
!(tagFlags[a.type] & 768) &&
a.format === b.format);
var unionLiteralEqual = (a, b) =>
a === b || (a !== a && b !== b);
var unionOutput = (schema) => {
let output = schema;
while (
output.type !== neverTag &&
output.to !== U
) {
if (output.parser === B_neverSlot)
return never_;
output = output.to;
}
return output;
};
var unionNeverLink = (schema) => {
for (
let node = schema;
node !== U &&
node.type !== neverTag;
node = node.to
)
if (node.parser === B_neverSlot)
return true;
return false;
};
var unionIsTransparent = (schema) => {
if (schema.type !== anyOfTag)
return false;
let fields = 0;
for (const _key in schema) fields++;
return fields === 6;
};
var unionTraits = (schema) => {
const tag = tagFlags[schema.type];
let traits = 0;
if (tag & 4864 || schema.parser !== U)
return 15;
if (
schema.refiner !== U ||
schema.inputRefiner !== U
)
traits |= 3;
else if (tag & 8384) traits |= 2;
if (
schema.format !== U ||
isLiteral(schema)
)
traits |= 1;
const to2 = schema.to;
if (to2 !== U) {
if (
to2 === schema ||
to2.parser !== U ||
tagFlags[to2.type] & 4864
)
traits |= 15;
else if (
!(
to2.noValidation === true ||
tagFlags[to2.type] & 1 ||
unionRuntimeSame(schema, to2) ||
(to2.type === anyOfTag &&
unionMask(to2, 1, 0) & tag)
)
)
traits |= 9;
else traits |= unionTraits(to2);
}
const fields =
schema.items || schema.properties;
for (const key in fields) {
const field = fields[key];
traits |= unionTraits(field);
}
if (
typeof schema.additionalItems ===
"object"
)
traits |= unionTraits(
schema.additionalItems,
);
return traits;
};
var unionIsNoop = (schema) => {
if (
schema.to !== U ||
schema.parser !== U ||
tagFlags[schema.type] & 512
)
return false;
const fields =
schema.anyOf ||
schema.items ||
schema.properties;
for (const key in fields)
if (!unionIsNoop(fields[key]))
return false;
return (
typeof schema.additionalItems !==
"object" ||
unionIsNoop(schema.additionalItems)
);
};
var unionFail = (
schema,
path,
input,
...unionErrors
) =>
B_throw(
B_makeInvalidInputDetails(
schema,
unknown,
path,
input,
unionErrors.length
? unionErrors
: U,
),
);
var unionEmitChain = (cases, ctx) => {
if (cases.length === 1) {
const c = cases[0];
if (c.b === "" && c.c === "")
return "";
if (c.b === "")
return `if(!(${c.c})){${ctx.f("")}}`;
if (c.c === "")
return c.b.endsWith(";")
? c.b
: c.b + ";";
return `if(${c.c}){${c.b}}else{${ctx.f("")}}`;
}
let code = "";
let caught = false;
let exhaustive = false;
let open = false;
const attempt = (c, idx) => {
open = false;
if (c.b === "") return "break";
const body = c.b.endsWith(";")
? c.b
: `${c.b};`;
if (
c.f & 1 &&
(c.f & 8 || caught)
) {
caught = open = true;
return `try{${body}break}catch(x){${c.f & 4 ? `x=${ctx.r()}(x);if(x.expected===${ctx.s()}){x=x.unionErrors;x&&(r||(r=[])).push(...x)}else{(r||(r=[])).push(x)}` : `(r||(r=[])).push(${ctx.r()}(x))`}${!(c.f & 8) && unconditional > idx ? `;${ctx.f(",...(r||[])")}` : ""}}`;
}
return `${body}break`;
};
let unconditional = -1;
for (
let idx = 0;
idx < cases.length;
idx++
)
if (cases[idx].c === "")
unconditional = idx;
let last = "";
for (
let idx = 0;
idx < cases.length;
idx++
) {
const c = cases[idx];
const shared =
c.c !== "" && c.c === last;
if (shared && !open) continue;
const arm = attempt(c, idx);
last = c.c;
if (shared)
code = `${code.slice(0, -1)}${arm}}`;
else if (c.c === "") {
code += open ? arm : `${arm};`;
if (!open) {
exhaustive = true;
break;
}
} else
code +=
arm === "break"
? `if(${c.c})break;`
: `if(${c.c}){${arm}}`;
}
if (!exhaustive)
code += ctx.f(
caught ? ",...(r||[])" : "",
);
return `for(;;){${caught ? "let r;" : ""}${code}}`;
};
var unionOr = (cs) => {
const s2 = cs
.map((c) => c.c)
.join("||");
return cs.length > 1 ? `(${s2})` : s2;
};
var unionNarrowSchema = (schema) => {
const tagFlag = tagFlags[schema.type];
const container = 192;
const narrow = baseSchema(
schema.type,
false,
(input) => {
if (tagFlags[input.s.type] & 1)
return B_refine(
input,
input.e,
[
{
c: (inputVar) =>
typeCheckCond(
input,
schema,
inputVar,
),
f: failInvalidType,
},
],
);
if (
unionRuntimeSame(
input.s,
narrow,
)
)
return tagFlag & container
? B_refine(input, input.e)
: input;
if (
isLiteral(schema) &&
tagFlag & 1036
) {
input.e = schema;
const output =
schema.decoder(input);
input.e = narrow;
return output;
}
return schema.decoder(input);
},
);
narrow.encoder = schema.encoder;
if (schema.content !== U)
setContent(narrow, schema.content);
if (tagFlag & 8192)
narrow.class = schema.class;
else if (tagFlag & container) {
narrow.additionalItems = unknown;
if (tagFlag & 64)
narrow.properties =
immutableEmptyObject;
else
narrow.items =
immutableEmptyArray;
} else if (tagFlag & 2096)
narrow.const = schema.const;
else if (
tagFlag & 2 &&
schema.format !== U &&
schema.format !== "json"
) {
narrow.format = schema.format;
narrow.formatFlag =
schema.formatFlag;
narrow.noValidation =
schema.noValidation;
}
return narrow;
};
var unionWiden = (tagFlag, nan2) =>
tagFlag |
(tagFlag & 8256
? 8256
: tagFlag & tagFlags[numberTag]
? nan2
: 0);
var unionRefDef = (schema) => {
const defs = schema["$defs"],
ref = schema["$ref"];
if (defs === U || ref === U) return U;
const resolved =
defs[
ref.slice(
ref.lastIndexOf("/") + 1,
)
];
return resolved !== U &&
resolved !== schema
? resolved
: U;
};
var unionMask = (
schema,
mode,
nan2,
) => {
if (mode === 2) {
const resolved =
unionRefDef(schema);
if (resolved !== U)
return unionMask(
resolved,
1,
nan2,
);
}
const tagFlag = tagFlags[schema.type];
if (!mode && tagFlag & 32768)
return 0;
if (mode && tagFlag & 256) {
let mask = 0;
const variants = schema.anyOf;
for (
let i = 0;
i < variants.length;
i++
)
mask |= unionMask(
variants[i],
1,
nan2,
);
return mask;
}
return tagFlag & 769
? -1
: unionWiden(tagFlag, nan2);
};
var unionGroup = (member) => ({
m: member.m,
a: [member],
f: member.f & 16,
p: member.p,
o: false,
});
var unionDiscriminator = (schema) => {
if (isLiteral(schema))
return ["", schema.const];
const fields =
schema.properties || schema.items;
for (const key in fields) {
const field = fields[key];
if (isLiteral(field))
return [key, field.const];
}
return U;
};
var unionDropNullish = (
variants,
other,
outputSide,
) => {
if (
other === U ||
tagFlags[other.type] & 817 ||
other.format === "json" ||
other.format === "env"
)
return variants;
const kept = variants.filter(
(variant) =>
!(
tagFlags[
(outputSide
? unionOutput(variant)
: variant
).type
] & 48
),
);
return kept.length ? kept : variants;
};
var unionCheckPartial = (
input,
source,
target,
variants,
outputSide,
) => {
const other = outputSide
? target
: source;
let matched = U;
let unmatched = U;
for (
let idx = 0;
idx < variants.length;
idx++
) {
const variant = variants[idx];
const match = outputSide
? unionOutput(variant)
: variant;
if (
variant.type === neverTag ||
(outputSide
? match.type === neverTag
: unionNeverLink(variant))
)
continue;
if (unionSameType(other, match))
matched || (matched = variant);
else
unmatched ||
(unmatched = variant);
}
if (matched !== U && unmatched !== U)
unionInvalid(
input,
source,
target,
unmatched,
outputSide,
);
};
var unionPeer = (schema) =>
schema.anyOf?.find(
(variant) =>
!(tagFlags[variant.type] & 32816),
) || schema;
var unionInvalid = (
input,
source,
target,
member,
onSource,
) => {
const it =
inputExpression(
member,
);
const conversion = onSource
? `${it} -> ${/* @__PURE__ */ inputExpression(unionPeer(target))}`
: `${/* @__PURE__ */ inputExpression(unionPeer(source))} -> ${it}`;
return B_invalidOperation(
input,
`Ambiguous ${/* @__PURE__ */ inputExpression(source)} -> ${/* @__PURE__ */ inputExpression(target)}. Should ${it} be decoded or ignored? Choose with S.to for ${conversion}, or S.never -> ${it}`,
);
};
var unionAnalyze = (
sourceMask,
flags,
sourceTag,
variants,
source,
nan2,
) => {
const out = [];
const unknownSource = sourceTag & 1;
const sourceBoundary =
sourceTag & 768;
const unionSource =
sourceBoundary && sourceMask !== -1;
const sourceDiscriminator =
unionDiscriminator(source);
const exact = flags & 1;
const broadObject = flags & 64;
const broadNumber =
flags & tagFlags[numberTag];
const numberish =
tagFlags[numberTag] | 2048;
for (
let i = 0;
i < variants.length;
i++
) {
const s2 = variants[i];
const tag = tagFlags[s2.type];
const inputMask = unionMask(
s2,
1,
nan2,
);
const d = unionDiscriminator(s2);
const same = unionRuntimeSame(
source,
s2,
);
const discriminatorDisjoint =
sourceDiscriminator !== U &&
d !== U &&
same &&
sourceDiscriminator[0] === d[0] &&
!unionLiteralEqual(
sourceDiscriminator[1],
d[1],
);
const accepts =
!(tag & 32768) &&
!unionNeverLink(s2) &&
!discriminatorDisjoint &&
(!exact ||
(isLiteral(s2)
? unionLiteralEqual(
s2.const,
source.const,
)
: sourceMask & inputMask));
const native = sourceMask & tag;
const coerces =
accepts &&
!unknownSource &&
!(unionSource ? native : same);
const output = unionOutput(s2);
const traits = unionTraits(s2);
const sourceDeopt =
sourceBoundary &&
(!unionSource || coerces);
const effect =
output.type === neverTag
? 3
: traits & 4 || sourceDeopt
? 4
: coerces || traits & 8
? 2
: traits & 1 || tag & 9152
? 1
: 0;
out[i] = {
i,
s: s2,
m: accepts
? unknownSource
? inputMask
: unionSource
? native
? inputMask
: s2.type ===
undefinedTag &&
sourceMask & 32
? 32
: s2.type === nullTag &&
sourceMask & 16
? 16
: sourceMask & 2
? 2
: sourceMask
: sourceMask
: 0,
o:
!!accepts &&
output.type !== neverTag,
e: effect,
f:
(traits & 7) |
(effect ? 1 : 0) |
(sourceDeopt ? 4 : 0) |
((!unknownSource && same) ||
tag & 37633
? 16
: 0),
p:
(s2.type === objectTag &&
nestedLoc in s2.properties) ||
(broadObject && tag & 8320) ||
(broadNumber && tag & 2048)
? 0
: d !== U
? 1
: 2,
k:
tag & 8192
? s2.class
: s2.format === "env"
? s2.format
: s2.type,
n: unionNarrowSchema(s2),
r:
tag & 8256
? 8256
: tag & numberish
? numberish
: unionWiden(tag, nan2),
d,
};
}
return out;
};
var unionPlan = (members) => {
var _a;
const sequence = [];
const active = [];
const priority = [];
let total = 0;
let effects = 0;
for (
let i = 0;
i < members.length;
i++
) {
const member = members[i];
if (member.e > 1)
effects |= member.m;
else if (!member.e)
total |= member.m;
}
for (
let i = 0;
i < members.length;
i++
) {
const member = members[i];
if (
member.m === 0 ||
(member.e === 1 &&
!(member.f & 2) &&
!(
member.m &
(effects | ~total)
))
)
continue;
const bucketed =
member.r !== -1 &&
(member.m & ~member.r) === 0;
const compatible =
member.e < 2 ||
(member.d !== U &&
(member.e === 4 ||
member.d[0] !== ""));
let bucket = bucketed
? member.p === 0
? priority[member.r] ||
active[member.r]
: active[member.r]
: U;
let open = U;
let broad = false;
if (bucket !== U)
for (
let j = 0;
j < bucket.t.length;
j++
) {
const group = bucket.t[j];
const first = group.a[0];
broad ||
(broad = group.p === 2);
if (
open === U &&
compatible &&
group.o &&
first.k === member.k &&
(first.e < 2 ===
member.e < 2 ||
(first.d !== U &&
first.d[0] ===
member.d?.[0])) &&
(group.p === 0) ===
(member.p === 0)
)
open = group;
else if (
group.o &&
group.m & member.m
)
group.o = false;
}
for (const key in active) {
const other = active[+key];
if (
other !== bucket &&
other.m & member.m
)
delete active[+key];
}
if (!bucketed) {
for (const key in priority)
if (priority[+key].m & member.m)
delete priority[+key];
sequence.push(unionGroup(member));
continue;
}
if (
bucket !== U &&
open === U &&
member.p === 1 &&
broad
) {
delete active[member.r];
bucket = U;
}
if (bucket === U) {
bucket = {
m: 0,
t: [],
};
active[member.r] = bucket;
priority[(_a = member.r)] ||
(priority[_a] = bucket);
sequence.push(bucket);
}
bucket.m |= member.m;
if (open !== U) {
open.a.push(member);
open.m |= member.m;
open.f &= -17;
} else {
const group = unionGroup(member);
group.o = compatible;
bucket.t.push(group);
}
if (!compatible)
delete active[member.r];
}
const plan = [];
for (
let i = 0;
i < sequence.length;
i++
) {
const item = sequence[i];
if ("a" in item) plan.push(item);
else
plan.push(
...item.t.sort(
(a, b) => a.p - b.p,
),
);
}
const later = [];
let laterMask = 0;
let laterBroad = 0;
for (
let i = plan.length - 1;
i >= 0;
i--
) {
const group = plan[i];
let key = U;
let values;
for (
let j = group.a.length - 1;
j >= 0;
j--
) {
const member = group.a[j];
const d = member.d;
const conflict2 =
d === U ||
key === false ||
(key !== U && key !== d[0]);
if (
key !== U &&
(conflict2 || values.has(d[1]))
) {
member.f |= 8;
group.f |= 2;
}
if (conflict2) key = false;
else {
key = d[0];
(
values ||
(values =
new Set())
).add(d[1]);
}
}
const head = group.a[0];
const route = head.r;
const semantic = later[route];
let overlaps =
!!(laterMask & group.m) &&
(!!(laterBroad & group.m) ||
key === false ||
semantic === U ||
semantic === false ||
semantic[0] !== key);
if (
!overlaps &&
semantic !== U &&
semantic !== false
) {
for (const value of values)
if (semantic[1].has(value)) {
overlaps = true;
break;
}
}
if (
overlaps ||
(laterMask &&
tagFlags[head.s.type] & 37633 &&
(head.s.to !== U ||
head.s.parser !== U))
)
group.f |= 10;
if (
route !== -1 &&
(group.m & ~route) === 0
) {
if (key === false)
later[route] = false;
else if (semantic === U)
later[route] = [key, values];
else if (semantic !== false) {
if (semantic[0] !== key)
later[route] = false;
else
for (const value of values)
semantic[1].add(value);
}
} else laterBroad |= group.m;
if (laterMask & group.m)
group.f |= 32;
laterMask |= group.m;
}
return plan;
};
var unionEmit = (
input,
self,
expectedSchema,
plan,
toPerCase,
trustedSelf,
) => {
const initialInline = input.i;
let output = B_refine(input);
const awaitAsync = plan.some(
(group) => group.f & 2,
);
const outputBySource = [];
let salvaged = "";
let rethrow = "";
let expected = "";
const ctx = {
f: (caught) =>
`${B_embed(input, unionFail.bind(U, expectedSchema, input.path))}(${input.v()}${salvaged}${caught})`,
r: () =>
rethrow ||
(rethrow = B_embed(
input,
getOrRethrow,
)),
s: () =>
expected ||
(expected = B_embed(
input,
expectedSchema,
)),
};
const unionDTrusted = (member) => {
const d = member.d;
const tag = tagFlags[member.s.type];
for (const group of plan)
for (const m of group.a) {
if (m === member) continue;
if (
m.d !== U
? m.d[0] === d[0] &&
unionLiteralEqual(
m.d[1],
d[1],
)
: m.m & tag
)
return false;
}
return true;
};
const compile2 = (
member,
source,
target,
) => {
const mark = input.g.t;
const caseInput = B_scope(source);
caseInput.u = true;
caseInput.t = source.t;
caseInput.io = false;
caseInput.e = member.s;
if (source.s === target.e)
caseInput.s = member.n;
const trustedD =
trustedSelf &&
member.p === 1 &&
!(member.f & 8) &&
member.d[0] !== "" &&
unionDTrusted(member)
? member.d
: U;
if (trustedD !== U)
caseInput.s = member.s;
let caseOut;
const options = input.g.o;
input.g.o |= 4;
try {
caseOut = parse(caseInput);
} catch (exn) {
if (!self.perVariant) throw exn;
salvaged += `,${B_embed(input, getOrRethrow(exn))}`;
return U;
} finally {
input.g.o = options;
}
if (member.o)
outputBySource[member.i] =
caseOut.s;
const cond = {
c: "",
h: [],
};
let body = B_merge(caseOut, cond);
const async = caseOut.f & 1;
output.f |= async;
if (caseOut.t) {
output.t = true;
const itemVar = target.v();
if (
async ||
caseOut.i !== itemVar
) {
body += `${itemVar}=${async && awaitAsync ? "await " : ""}${caseOut.i}`;
if (itemVar === operationArgVar)
input.g.r = true;
}
}
if (trustedD !== U) {
const dSchema = (member.s
.properties || member.s.items)[
trustedD[0]
];
const dRead = inlinedProperty(
source.v(),
trustedD[0],
);
const dCond =
dSchema.type === nanTag
? `Number.isNaN(${dRead})`
: `${dRead}===${B_inlineConst(caseInput, dSchema)}`;
cond.c = cond.c
? `${dCond}&&${cond.c}`
: dCond;
}
return {
c: cond.c,
b: body,
f:
(body !== "" &&
input.g.t !== mark
? 1
: 0) |
(async && awaitAsync ? 2 : 0) |
(member.f & 8),
};
};
const cases = [];
for (
let i = 0;
i < plan.length;
i++
) {
const group = plan[i];
if (
group.a.length === 1 &&
group.f & 16
) {
const c = compile2(
group.a[0],
input,
input,
);
if (c !== U) {
c.f |= group.f & 8;
cases.push(c);
if (c.c === "" && c.b === "")
break;
}
continue;
}
const mark = input.g.t;
const groupNarrow = group.a[0].n;
const narrowInput = B_scope(input);
narrowInput.io = false;
narrowInput.e = groupNarrow;
const narrow = parse(narrowInput);
if (
tagFlags[groupNarrow.type] & 192
) {
const resolved = unionRefDef(
input.s,
);
const sourceVariant =
resolved !== U &&
resolved.anyOf !== U
? resolved.anyOf.find(
(v) =>
v.type ===
groupNarrow.type,
)
: U;
if (sourceVariant !== U)
narrow.s = sourceVariant;
}
const inner = [];
for (
let j = 0;
j < group.a.length;
j++
) {
const c = compile2(
group.a[j],
narrow,
narrowInput,
);
if (c !== U) {
inner.push(c);
if (c.c === "" && c.b === "")
break;
}
}
if (!inner.length) continue;
const cond = {
c: "",
h: [],
};
let body;
let grouped = false;
if (
inner.every((c) => c.b === "")
) {
if (
!inner.some((c) => c.c === "")
) {
const fused = unionOr(inner);
body = B_merge(
B_refine(narrow, narrow.s, [
{
c: () => fused,
f: failInvalidType,
},
]),
cond,
);
} else
body = B_merge(narrow, cond);
} else {
const narrowCode = B_merge(
narrow,
cond,
);
const only =
inner.length === 1
? inner[0]
: U;
if (
only !== U &&
narrowCode === ""
) {
if (only.c !== "")
cond.c = cond.c
? `${cond.c}&&${only.c}`
: only.c;
body = only.b;
} else {
if (
inner.length > 1 &&
group.f & 32 &&
inner.every((c) => c.c)
) {
const fused = unionOr(inner);
cond.c = cond.c
? `${cond.c}&&${fused}`
: fused;
}
body =
narrowCode +
unionEmitChain(inner, ctx);
grouped = inner.length > 1;
}
}
cases.push({
c: cond.c,
b: body,
f:
(body !== "" &&
input.g.t !== mark
? 1
: 0) |
(inner.some((c) => c.f & 2)
? 2
: 0) |
(group.f & 8) |
(grouped ? 4 : 0),
});
if (body === "" && cond.c === "")
break;
}
const noop =
cases.every((c) => c.b === "") &&
cases.some((c) => c.c === "");
const pure =
!noop &&
cases.length > 0 &&
cases.every(
(c) => c.c !== "" && c.b === "",
);
const asyncDispatch = cases.some(
(c) => c.f & 2,
);
if (pure) {
const fused = unionOr(cases);
output = B_refine(
B_refine(
output,
output.s,
[
{
c: () => fused,
f: failInvalidType,
},
],
expectedSchema,
),
);
} else if (!noop) {
const dispatch2 = unionEmitChain(
cases,
ctx,
);
if (asyncDispatch) {
const itemVar = input.v();
output.i = `(async(${itemVar})=>{${dispatch2};return ${itemVar}})(${itemVar})`;
} else output.cp += dispatch2;
}
if (!asyncDispatch)
output.i = input.i;
let out;
if (output.f & 1) {
output.i = `Promise.resolve(${output.i})`;
output.v = _notVar;
out = output;
} else if (
output.v === _var &&
input.cp === "" &&
output.cp === "" &&
!pure &&
initialInline === "i"
) {
input.hd = "";
input.v = _notVar;
input.i = initialInline;
out = input;
} else out = output;
const outputAnyOf =
outputBySource.filter(Boolean);
out.s = outputAnyOf.length
? unionFactory(outputAnyOf)
: never_;
if (toPerCase !== U) {
out.io = true;
out.e = unionOutput(toPerCase);
return out;
}
out.e = self;
return B_markOutput(out, input);
};
var unionDecoder = (input) => {
const self = input.e;
const toPerCase =
self.parser === U &&
self.to !== U &&
self.to.noValidation !== true
? self.to
: U;
let variants = self.anyOf;
if (
(input.io && input.e === input.s) ||
(input.s === self &&
toPerCase === U &&
variants.every(unionIsNoop)) ||
(input.s.type === anyOfTag &&
toPerCase === U &&
input.s.anyOf.every(
(inS, idx) => {
const s2 = variants[idx];
return (
s2 !== U &&
!(
tagFlags[inS.type] & 9152
) &&
inS.type === s2.type &&
unionLiteralEqual(
inS.const,
s2.const,
) &&
inS.to === U &&
s2.to === U
);
},
))
)
return input;
const initialTagFlag =
tagFlags[input.s.type];
const trustedSelf =
input.s === self || self.tr;
if (
initialTagFlag & 256 ||
(input.s.encoder === U &&
initialTagFlag & 512)
)
input.s = unknown;
if (variants.every(unionNeverLink))
B_invalidOperation(
input,
`Nothing decodes ${/* @__PURE__ */ inputExpression(self)}. Every member is S.never`,
);
const source = input.s;
variants = unionDropNullish(
unionDropNullish(
variants,
source,
false,
),
toPerCase,
true,
);
let expected = self;
if (variants !== self.anyOf) {
expected = copySchema(self);
expected.anyOf = variants;
}
const nan2 = input.g.o & 2 ? 2048 : 0;
let flags = 0;
const sourceLiteral =
isLiteral(source);
for (
let i = 0;
i < variants.length;
i++
) {
const member = variants[i];
if (
sourceLiteral &&
isLiteral(member) &&
unionLiteralEqual(
member.const,
source.const,
)
)
flags |= 1;
flags |=
tagFlags[member.type] &
(64 | tagFlags[numberTag]);
}
const sourceTag =
tagFlags[source.type];
if (!(sourceTag & 1) && !(flags & 1))
unionCheckPartial(
input,
source,
self,
variants,
false,
);
if (toPerCase !== U) {
const perCase = unionTargetOwns(
toPerCase,
)
? variants.map((v) =>
unionOutput(v).type ===
neverTag
? U
: toPerCase,
)
: unionResolve(
input,
self,
variants,
toPerCase,
);
const attach =
self.refiner !== U ||
self.inputRefiner !== U
? unionRefinerAttacher(self)
: U;
variants = variants.map(
(variant, idx) => {
const to2 = perCase[idx];
return to2 === U && attach === U
? variant
: updateOutput(
variant,
(mut) => {
if (attach !== U)
attach(mut);
if (to2 !== U)
mut.to = to2;
},
);
},
);
}
return unionEmit(
input,
self,
expected,
unionPlan(
unionAnalyze(
unionMask(source, 2, nan2),
flags,
sourceTag,
variants,
source,
nan2,
),
),
toPerCase,
trustedSelf,
);
};
var unionRefinerAttacher = (self) => {
const cached = [];
return (mut) => {
for (let i = 0; i < 2; i++) {
const key = i
? "inputRefiner"
: "refiner";
const source = self[key];
if (source !== U) {
const current = mut[key];
mut[key] = (input) => {
const shared =
cached[i] ||
(cached[i] = source(input));
return current === U
? shared
: current(input).concat(
shared,
);
};
}
}
};
};
var unionRewrite = (
input,
variants,
map,
) => {
const anyOf = [];
const has = {};
for (
let idx = 0;
idx < variants.length;
idx++
) {
const rewritten = map(
variants[idx],
idx,
);
anyOf.push(rewritten);
setHas(has, rewritten.type);
}
const mut = baseSchema(
anyOfTag,
false,
unionDecoder,
);
mut.anyOf = anyOf;
mut.has = has;
mut.encoder = unionEncoder;
mut.perVariant = input.s.perVariant;
mut.tr = true;
return B_refine(
input,
unknown,
U,
mut,
);
};
var unionTargetOwns = (target) =>
target.noValidation === true ||
tagFlags[unionOutput(target).type] &
512 ||
(target.type === anyOfTag &&
target.anyOf.some(
(v) => tagFlags[v.type] & 512,
));
var unionEncoder = (input, target) => {
input.s;
if (unionTargetOwns(target))
return input;
const variants = unionDropNullish(
input.s.anyOf,
target,
true,
);
if (
target.perVariant &&
target.anyOf.length ===
variants.length
) {
const targets = target.anyOf;
return targets.every(
(tv, idx) => tv === variants[idx],
)
? input
: unionRewrite(
input,
variants,
(_variant, idx) =>
targets[idx],
);
}
const resolved = unionResolve(
input,
input.s,
variants,
target,
);
if (
resolved.every((to2) => to2 === U)
)
return input;
return unionRewrite(
input,
variants,
(variant, idx) => {
const to2 = resolved[idx];
return to2 === U
? variant
: updateOutput(
variant,
(mut) => {
mut.to = to2;
},
);
},
);
};
var unionOpposite = (schema) =>
schema.type === undefinedTag
? nullTag
: schema.type === nullTag
? undefinedTag
: U;
var unionResolve = (
input,
source,
variants,
target,
) => {
if (source.perVariant)
return variants.map(() => target);
if (unionIsTransparent(target))
return unionResolveToUnion(
input,
source,
variants,
target,
);
if (
!(tagFlags[target.type] & 1) &&
!target.noValidation
)
unionCheckPartial(
input,
source,
target,
variants,
true,
);
return variants.map((variant) =>
unionOutput(variant).type ===
neverTag
? U
: target,
);
};
var unionResolveToUnion = (
input,
source,
variants,
target,
) => {
const targets = target.anyOf;
const matches = [];
const covered = [];
let sourceNullish = 0;
for (
let s2 = 0;
s2 < variants.length;
s2++
) {
const sourceVariant = variants[s2];
const sourceOut = unionOutput(
sourceVariant,
);
if (
!(
sourceVariant.type !==
neverTag &&
sourceOut.type !== neverTag
)
)
continue;
if (
sourceOut === target ||
(target.anyOf !== U &&
sourceOut.anyOf ===
target.anyOf)
) {
for (
let t = 0;
t < targets.length;
t++
)
covered[t] = true;
continue;
}
const sameTyped = targets.filter(
(targetVariant, t) =>
targetVariant.type !==
neverTag &&
!unionNeverLink(
targetVariant,
) &&
unionSameType(
sourceOut,
targetVariant,
) &&
(covered[t] = true),
);
sourceNullish |=
tagFlags[sourceOut.type] & 48;
if (sameTyped.length === 1)
matches[s2] = sameTyped[0];
else if (sameTyped.length > 1)
matches[s2] =
tagFlags[sourceOut.type] &
9152 &&
sameTyped.includes(sourceOut)
? sourceOut
: unionFactory(sameTyped);
if (matches[s2] !== U) continue;
const opposite =
unionOpposite(sourceOut);
if (opposite !== U)
matches[s2] = targets.find(
(candidate) =>
candidate.type === opposite &&
!unionNeverLink(candidate) &&
unionOutput(candidate)
.type !== neverTag,
);
if (matches[s2] === U)
unionInvalid(
input,
source,
target,
sourceOut,
true,
);
}
for (
let t = 0;
t < targets.length;
t++
) {
const targetVariant = targets[t];
const opposite = unionOpposite(
targetVariant,
);
if (
targetVariant.type !== neverTag &&
!unionNeverLink(targetVariant) &&
!covered[t] &&
(opposite === U ||
unionOutput(targetVariant)
.type === neverTag ||
!(
sourceNullish &
tagFlags[opposite]
))
)
unionInvalid(
input,
source,
target,
targetVariant,
false,
);
}
return matches.map((matched, idx) => {
if (matched === U) return matched;
const sourceOut = unionOutput(
variants[idx],
);
return matched === sourceOut ||
(unionIsNoop(matched) &&
matched.refiner === U &&
matched.inputRefiner === U &&
matched.noValidation === U &&
(matched.const === U ||
unionLiteralEqual(
matched.const,
sourceOut.const,
)) &&
!(
tagFlags[matched.type] & 9152
) &&
unionSameType(
matched,
sourceOut,
))
? U
: matched;
});
};
var unionFactory = (schemas) => {
if (!schemas.length)
return panic(
"S.union requires at least one item",
);
if (schemas.length === 1)
return schemas[0];
const has = {};
const anyOf = [];
for (
let idx = 0;
idx < schemas.length;
idx++
) {
const schema = schemas[idx];
const nested = unionIsTransparent(
schema,
)
? schema.anyOf
: [schema];
for (
let j = 0;
j < nested.length;
j++
) {
const member = nested[j];
anyOf.push(member);
setHas(has, member.type);
}
}
const mut = baseSchema(
anyOfTag,
false,
unionDecoder,
);
mut.anyOf = anyOf;
mut.encoder = unionEncoder;
mut.has = has;
return mut;
};
var internalRefine = (
schema,
makeRefiner,
) => {
return updateOutput(schema, (mut) => {
const refiner = makeRefiner(mut);
const existingRefiner = mut.refiner;
if (existingRefiner !== U)
mut.refiner = (input) => {
const arr =
existingRefiner(input);
arr.push(...refiner(input));
return arr;
};
else mut.refiner = refiner;
});
};
var getMutErrorMessage = (mut) => {
const em = mut.errorMessage
? { ...mut.errorMessage }
: {};
mut.errorMessage = em;
return em;
};
var codecTo = (
schema,
target,
decode,
encode,
) => {
return updateOutput(schema, (mut) => {
const opened =
typeof decode === "boolean";
const parser =
typeof decode === functionTag
? decode
: U;
const serializer =
typeof encode === functionTag
? encode
: U;
if (serializer !== U || opened) {
const targetMut =
copySchema(target);
if (serializer !== U)
targetMut.serializer =
serializer;
if (opened)
targetMut.opens = decode;
mut.to = targetMut;
} else mut.to = target;
if (
mut.content !== U &&
mut.opens === U
)
mut.opens = true;
if (parser !== U)
mut.parser = parser;
});
};
var nullAsUnit = copyTo(
nullLiteral,
unit,
);
var Option_getWithDefault = (
schema,
default_,
) => {
return updateOutput(schema, (mut) => {
const anyOf = mut.anyOf;
if (anyOf === U)
return panic(
`Can't set default for ${/* @__PURE__ */ inputExpression(mut)}`,
);
const outputItems = [];
const originalItems = [];
for (
let idx = 0;
idx < anyOf.length;
idx++
) {
const variant = anyOf[idx];
const outputSchema =
getOutputSchema(variant);
if (
outputSchema.type !==
undefinedTag
) {
if (
!outputItems.includes(
outputSchema,
)
)
outputItems.push(
outputSchema,
);
originalItems.push(variant);
}
}
const item =
outputItems.length === 0
? panic(
`Can't set default for ${/* @__PURE__ */ inputExpression(mut)}`,
)
: outputItems.length === 1
? outputItems[0]
: unionFactory(outputItems);
if (default_.type === "value") {
const v = default_.value;
try {
getOp(
0,
2,
unknown,
item,
)(v);
} catch (exn) {
const error = getOrRethrow(exn);
panic(
`Invalid default for ${/* @__PURE__ */ inputExpression(mut)}: ${error["message"]}`,
);
}
const originalItem =
originalItems.length === 1
? originalItems[0]
: unionFactory(originalItems);
try {
mut.default =
getOp(
0,
1,
reverse(
originalItem,
),
)(v);
} catch (_exn) {}
}
const decodeB = (input) => {
const target = input.e.to;
const output = B_next(
input,
default_.type === "value"
? B_inlineConst(
input,
Literal_parse(
default_.value,
),
)
: `${B_embed(input, default_.callback)}()`,
target,
target,
);
if (default_.type === "value")
output.v = _var;
return B_refine(output);
};
mut.anyOf = anyOf.map((variant) =>
getOutputSchema(variant).type ===
undefinedTag
? codecTo(
variant,
item,
decodeB,
B_neverSlot,
)
: variant,
);
});
};
var Option_getOr =
(
schema,
defaultValue,
) =>
Option_getWithDefault(schema, {
type: "value",
value: defaultValue,
});
var Option_getOrWith =
(
schema,
defaultCb,
) =>
Option_getWithDefault(schema, {
type: "callback",
callback: defaultCb,
});
var expects = (fnName, expected, got) =>
`S.${fnName} expects ${expected}, got ${got}`;
var assertNumericBound = (
fnName,
root,
value,
) => {
const schema = getOutputSchema(root);
const tag = schema.type;
if (
tag !== numberTag &&
tag !== bigintTag
)
panic(
expects(
fnName,
"number | bigint schema",
inputExpression(
schema,
),
),
);
if (
tag === bigintTag
? typeof value !== bigintTag
: typeof value !== numberTag ||
Number.isNaN(value)
)
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason: expects(
fnName,
inputExpression(
schema,
),
stringify(value),
),
});
return schema;
};
var assertLengthBound = (
fnName,
root,
value,
) => {
const schema = getOutputSchema(root);
if (
schema.type !== stringTag &&
schema.type !== arrayTag
)
panic(
expects(
fnName,
"string | array schema",
inputExpression(
schema,
),
),
);
if (
typeof value !== numberTag ||
!Number.isSafeInteger(value) ||
value < 0
)
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason: expects(
fnName,
"integer >= 0",
stringify(value),
),
});
return schema;
};
var lit = (value) =>
typeof value === bigintTag
? `${value}n`
: `${value}`;
var sizeKey = (schema, upper) =>
schema.type === arrayTag
? upper
? "maxItems"
: "minItems"
: schema.type === instanceTag
? upper
? "maxSize"
: "minSize"
: upper
? "maxLength"
: "minLength";
var sizeMember = (schema) => {
const tag = schema.type;
return tag === instanceTag
? ".size"
: tag === stringTag ||
tag === arrayTag
? ".length"
: U;
};
var withBounds = (schema, base) => {
const written = schema.bounds ?? 0;
const member = sizeMember(schema);
const sized = member !== U;
const minKey = sized
? sizeKey(schema, false)
: "minimum";
const maxKey = sized
? sizeKey(schema, true)
: "maximum";
const exMin =
written & 4
? schema.exclusiveMinimum
: U;
const exMax =
written & 8
? schema.exclusiveMaximum
: U;
const high =
exMax !== U
? exMax
: written & 2
? schema[maxKey]
: U;
const low =
exMin !== U
? exMin
: written & 1 &&
!(
sized &&
schema[minKey] === 0 &&
high !== 0
)
? schema[minKey]
: U;
const mo = schema.multipleOf;
const subject0 = sized
? `${base}${member}`
: base;
if (low === U && high === U)
return mo !== U
? `${subject0} % ${lit(mo)}`
: base;
const subject =
mo !== U
? `(${subject0} % ${lit(mo)})`
: subject0;
if (low === U)
return `${subject} ${exMax !== U ? "<" : "<="} ${lit(high)}`;
if (high === U)
return `${subject} ${exMin !== U ? ">" : ">="} ${lit(low)}`;
return exMin === U &&
exMax === U &&
low === high
? `${subject} == ${lit(low)}`
: `${lit(low)} ${exMin !== U ? "<" : "<="} ${subject} ${exMax !== U ? "<" : "<="} ${lit(high)}`;
};
var setBoundExpression = (
mut,
schema,
) => {
if (
schema.bounds === U &&
schema.multipleOf === U
) {
const base = schema.expression;
mut.expression = (s2) =>
withBounds(
s2,
base !== U
? base(s2)
: inputExpression(
s2,
true,
),
);
}
};
var exactDivisor = (d) =>
typeof d === bigintTag ||
Number.isInteger(d);
var multipleOfValidator =
(d) => (value) => {
const ratio = value / d;
return (
Math.abs(
ratio - Math.round(ratio),
) <
Number.EPSILON *
Math.max(Math.abs(ratio), 1)
);
};
var boundsRefiner = (input) => {
const s2 = input.e;
const written = s2.bounds ?? 0;
const checks = [];
const member = sizeMember(s2);
if (member !== U) {
const minKey = sizeKey(s2, false);
const maxKey = sizeKey(s2, true);
const min =
written & 1 ? s2[minKey] : U;
const max =
written & 2 ? s2[maxKey] : U;
const em = s2.errorMessage;
if (
min !== U &&
min === max &&
(em !== U ? em[minKey] : U) ===
(em !== U ? em[maxKey] : U)
)
checks.push({
c: (inputVar) =>
`${inputVar}${member}===${min}`,
f: B_failWithErrorMessage(
minKey,
),
});
else {
if (min)
checks.push({
c: (inputVar) =>
`${inputVar}${member}>${min - 1}`,
f: B_failWithErrorMessage(
minKey,
),
});
if (max !== U)
checks.push({
c: (inputVar) =>
`${inputVar}${member}<${max + 1}`,
f: B_failWithErrorMessage(
maxKey,
),
});
}
} else {
const exMin =
written & 4
? s2.exclusiveMinimum
: U;
const min =
exMin !== U
? exMin
: written & 1
? s2.minimum
: U;
if (min !== U)
checks.push({
c: (inputVar) =>
`${inputVar}${exMin !== U ? ">" : ">="}${lit(min)}`,
f: B_failWithErrorMessage(
exMin !== U
? "exclusiveMinimum"
: "minimum",
),
});
const exMax =
written & 8
? s2.exclusiveMaximum
: U;
const max =
exMax !== U
? exMax
: written & 2
? s2.maximum
: U;
if (max !== U)
checks.push({
c: (inputVar) =>
`${inputVar}${exMax !== U ? "<" : "<="}${lit(max)}`,
f: B_failWithErrorMessage(
exMax !== U
? "exclusiveMaximum"
: "maximum",
),
});
const mo = s2.multipleOf;
if (mo !== U) {
let cond;
if (typeof mo === bigintTag)
cond = (inputVar) =>
`!(${inputVar}%${lit(mo)})`;
else if (exactDivisor(mo))
cond = (inputVar) =>
`${inputVar}%${lit(mo)}==0`;
else {
const embedded = B_embed(
input,
multipleOfValidator(mo),
);
cond = (inputVar) =>
`${embedded}(${inputVar})`;
}
checks.push({
c: cond,
f: B_failWithErrorMessage(
"multipleOf",
),
});
}
}
return checks;
};
var updateBounds = (schema, update) =>
schema.bounds !== U ||
schema.multipleOf !== U
? updateOutput(schema, update)
: internalRefine(schema, (mut) => {
update(mut);
return boundsRefiner;
});
var carryMessage = (
schema,
key,
maybeMessage,
) =>
maybeMessage === U || key === U
? schema
: updateOutput(schema, (mut) => {
getMutErrorMessage(mut)[key] =
maybeMessage;
});
var setBoundMessage = (
mut,
schema,
key,
maybeMessage,
replaced,
) => {
const existing = schema.errorMessage;
if (maybeMessage !== U)
getMutErrorMessage(mut)[key] =
maybeMessage;
else if (
existing !== U &&
existing[key] !== U
)
getMutErrorMessage(mut)[key] = U;
if (
replaced !== U &&
existing !== U &&
existing[replaced] !== U
)
getMutErrorMessage(mut)[replaced] =
U;
};
var narrowsLower = (
schema,
value,
exclusive,
) => {
const bound = value;
const inclusive = schema.minimum;
const strict2 =
schema.exclusiveMinimum;
return (
(inclusive === U ||
(exclusive
? bound >= inclusive
: bound > inclusive)) &&
(strict2 === U || bound > strict2)
);
};
var narrowsUpper = (
schema,
value,
exclusive,
) => {
const bound = value;
const inclusive = schema.maximum;
const strict2 =
schema.exclusiveMaximum;
return (
(inclusive === U ||
(exclusive
? bound <= inclusive
: bound < inclusive)) &&
(strict2 === U || bound < strict2)
);
};
var narrowsSize = (
current,
value,
upper,
) =>
upper
? current === U || value < current
: value > (current ?? 0);
var conflict = (incoming, existing) => {
panic(
`${/* @__PURE__ */ inputExpression(incoming)} contradicts ${/* @__PURE__ */ inputExpression(existing)}`,
);
};
var asBound = (
schema,
key,
bit,
value,
) => {
const mut = {
...schema,
bounds: bit,
};
mut[key] = value;
setBoundExpression(mut, schema);
return mut;
};
var assertLower = (
schema,
value,
exclusive,
) => {
const key = exclusive
? "exclusiveMinimum"
: "minimum";
const bit = exclusive ? 4 : 1;
const bound = value;
const inclusive = schema.maximum;
const strict2 =
schema.exclusiveMaximum;
if (
inclusive !== U &&
(exclusive
? bound >= inclusive
: bound > inclusive)
)
conflict(
asBound(schema, key, bit, value),
asBound(
schema,
"maximum",
2,
inclusive,
),
);
if (strict2 !== U && bound >= strict2)
conflict(
asBound(schema, key, bit, value),
asBound(
schema,
"exclusiveMaximum",
8,
strict2,
),
);
};
var assertUpper = (
schema,
value,
exclusive,
) => {
const key = exclusive
? "exclusiveMaximum"
: "maximum";
const bit = exclusive ? 8 : 2;
const bound = value;
const inclusive = schema.minimum;
const strict2 =
schema.exclusiveMinimum;
if (
inclusive !== U &&
(exclusive
? bound <= inclusive
: bound < inclusive)
)
conflict(
asBound(schema, key, bit, value),
asBound(
schema,
"minimum",
1,
inclusive,
),
);
if (strict2 !== U && bound <= strict2)
conflict(
asBound(schema, key, bit, value),
asBound(
schema,
"exclusiveMinimum",
4,
strict2,
),
);
};
var assertSize = (
schema,
value,
upper,
) => {
const otherKey = sizeKey(
schema,
!upper,
);
const other = schema[otherKey];
if (
other !== U &&
(upper
? value < other
: value > other)
)
conflict(
asBound(
schema,
sizeKey(schema, upper),
upper ? 2 : 1,
value,
),
asBound(
schema,
otherKey,
upper ? 1 : 2,
other,
),
);
};
var gte = (
root,
minValue,
maybeMessage,
) => {
const schema = assertNumericBound(
"gte",
root,
minValue,
);
assertLower(schema, minValue, false);
if (
!narrowsLower(
schema,
minValue,
false,
)
) {
const written = schema.bounds ?? 0;
return carryMessage(
root,
written & 4
? "exclusiveMinimum"
: written & 1
? "minimum"
: U,
maybeMessage,
);
}
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds =
((schema.bounds ?? 0) & -5) | 1;
mut.minimum = minValue;
mut.exclusiveMinimum = U;
setBoundMessage(
mut,
schema,
"minimum",
maybeMessage,
"exclusiveMinimum",
);
});
};
var lte = (
root,
maxValue,
maybeMessage,
) => {
const schema = assertNumericBound(
"lte",
root,
maxValue,
);
assertUpper(schema, maxValue, false);
if (
!narrowsUpper(
schema,
maxValue,
false,
)
) {
const written = schema.bounds ?? 0;
return carryMessage(
root,
written & 8
? "exclusiveMaximum"
: written & 2
? "maximum"
: U,
maybeMessage,
);
}
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds =
((schema.bounds ?? 0) & -9) | 2;
mut.maximum = maxValue;
mut.exclusiveMaximum = U;
setBoundMessage(
mut,
schema,
"maximum",
maybeMessage,
"exclusiveMaximum",
);
});
};
var minLength =
(
root,
length2,
maybeMessage,
) => {
const schema = assertLengthBound(
"minLength",
root,
length2,
);
assertSize(schema, length2, false);
const key = sizeKey(schema, false);
if (
!narrowsSize(
schema[key],
length2,
false,
) &&
!(
length2 === 0 &&
schema[key] === U
)
)
return carryMessage(
root,
(schema.bounds ?? 0) & 1
? key
: U,
maybeMessage,
);
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds =
(schema.bounds ?? 0) | 1;
mut[key] = length2;
setBoundMessage(
mut,
schema,
key,
maybeMessage,
);
});
};
var maxLength =
(
root,
length2,
maybeMessage,
) => {
const schema = assertLengthBound(
"maxLength",
root,
length2,
);
assertSize(schema, length2, true);
const key = sizeKey(schema, true);
if (
!narrowsSize(
schema[key],
length2,
true,
)
)
return carryMessage(
root,
(schema.bounds ?? 0) & 2
? key
: U,
maybeMessage,
);
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds =
(schema.bounds ?? 0) | 2;
mut[key] = length2;
setBoundMessage(
mut,
schema,
key,
maybeMessage,
);
});
};
var nonEmpty =
(
schema,
maybeMessage,
) =>
minLength(
schema,
1,
maybeMessage,
);
var stringFormat =
(
format,
test,
flag,
expression,
) =>
initSchema(
stringTag,
stringDecoderFn,
(s2) => {
const re =
typeof test === "string"
? new RegExp(test, "i")
: test;
s2.format = format;
if (expression)
s2.expression = () =>
expression;
if (flag) s2.formatFlag = flag;
s2.refiner = (input) => {
return [
{
c: (inputVar) =>
`${B_embed(input, re)}${re instanceof RegExp ? ".test" : ""}(${inputVar})`,
f: B_failWithErrorMessage(
"format",
),
},
];
};
},
);
var ipv4Pattern =
"(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
var ipv6Pattern =
() =>
"(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|" +
ipv4Pattern +
")|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)";
var uriPattern =
(
schemeOptional,
scheme,
) =>
"^(?:" +
(scheme || "[a-z][a-z0-9+\\-.]*") +
":)" +
schemeOptional +
"(?:\\/\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:" +
ipv6Pattern() +
"|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|" +
ipv4Pattern +
"|(?:[a-z0-9\\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\\?(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$";
var uri = stringFormat(
"uri",
uriPattern(""),
1,
);
var invalidDateRefine = (input) => {
return B_refine(input, input.e, [
{
c: (inputVar) =>
`!Number.isNaN(${inputVar}.getTime())`,
f: failInvalidType,
},
]);
};
var dateTimeString =
initSchema(
stringTag,
stringDecoderFn,
(s2) => {
s2.format = "date-time";
s2.formatFlag = 1;
},
);
var date = initSchema(
instanceTag,
(input) => {
const inputTagFlag =
tagFlags[input.s.type];
if (inputTagFlag & 2)
return invalidDateRefine(
B_next(
input,
`new Date(${input.i})`,
date,
),
);
else if (inputTagFlag & 1)
return invalidDateRefine(
instanceDecoder(input),
);
else if (
inputTagFlag & 8192 &&
input.s.class === date.class
)
return input;
else
return B_unsupportedDecode(
input,
input.s,
input.e,
);
},
(s2) => {
s2.class = Date;
s2.encoder = (input, target) => {
if (tagFlags[target.type] & 2) {
if (input.s.noValidation)
return parse(
B_refine(
B_next(
input,
`${input.i}.toISOString()`,
dateTimeString,
target,
),
),
);
const output = B_nextVar(
input,
dateTimeString,
target,
);
output.cp = `let ${output.i};try{${output.i}=${input.v()}.toISOString()}catch(_){${B_embedInvalidInput(input, input.s)}}`;
return parse(B_refine(output));
} else return input;
};
},
);
var panicArity = () =>
panic(
"Expected at most 3 schemas and a value. Use .with(S.to, ...) for a longer chain",
);
var dispatch = (
n,
a,
b,
c,
d,
tail,
rev,
flag,
) => {
if (n > 4) panicArity();
let data = U;
let immediate = !isOwnSchema(a);
if (immediate) {
((data = a),
(a = b),
(b = c),
(c = d),
n--);
if (n < 1 || !isOwnSchema(a))
panicNotSchema();
}
const k =
n > 1 && isOwnSchema(b)
? n > 2 && isOwnSchema(c)
? 3
: 2
: 1;
if (n > k) {
if (immediate || n > k + 1)
panic(
"Expected a Sury schema. The data goes first or last",
);
data =
k > 2
? isOwnSchema(d)
? panicArity()
: d
: k > 1
? c
: b;
immediate = true;
}
const first = rev
? reverse(a)
: a;
const op =
k > 2
? getOp(
flag,
tail ? 4 : 3,
first,
b,
c,
tail,
)
: k > 1
? getOp(
flag,
tail ? 3 : 2,
first,
b,
tail,
)
: getOp(
flag,
tail ? 2 : 1,
first,
tail,
);
return immediate ? op(data) : op;
};
function parseOrThrow(a, b, c, d) {
return dispatch(
arguments.length,
a,
b,
c,
d,
U,
false,
8,
);
}
var getStandardJSONSchema = (
schema,
options,
isOutput2,
) => {
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason:
"~standard.jsonSchema requires S.enableStandardJSONSchema() to be called first",
});
};
Object.defineProperty(
schemaPrototype,
"toString",
{
value: function () {
const input =
inputExpression(
this,
);
const output =
inputExpression(
reverse(this),
);
return `Schema<${input === output ? input : `${input}, ${output}`}>`;
},
},
);
Object.defineProperty(
schemaPrototype,
"~standard",
{
get: function () {
const schema = this;
let opFlag = U;
let validateOp;
const standard = {
version: 1,
vendor,
validate: (input) => {
if (
opFlag !== globalConfig.f
) {
validateOp =
getOp(
1537,
2,
unknown,
schema,
);
opFlag = globalConfig.f;
}
return validateOp(input);
},
jsonSchema: {
input: (options) =>
getStandardJSONSchema(
schema,
options,
false,
),
output: (options) =>
getStandardJSONSchema(
schema,
options,
true,
),
},
};
valueOptions[valKey] = standard;
Object.defineProperty(
schema,
"~standard",
valueOptions,
);
return standard;
},
},
);
var union = (
values,
) =>
unionFactory(
values.map(definitionToSchema),
);
var nullable2 =
(
definition,
maybeOr,
) => {
const schema =
definitionToSchema(
definition,
);
if (maybeOr !== U) {
const schema2 = unionFactory([
schema,
nullAsUnit,
]);
if (
typeof maybeOr === functionTag
)
return Option_getOrWith(
schema2,
maybeOr,
);
else
return Option_getOr(
schema2,
maybeOr,
);
} else
return unionFactory([
schema,
nullLiteral,
]);
};
const imageSchema =
definitionToSchema({
id: float,
created: date,
title: string
.with(nonEmpty)
.with(maxLength, 100),
type: union([
"jpg",
"png",
]),
size: float,
url: uri,
});
const ratingSchema =
definitionToSchema({
id: float,
stars: float
.with(gte, 1)
.with(lte, 5),
title: string
.with(nonEmpty)
.with(maxLength, 100),
text: string
.with(nonEmpty)
.with(maxLength, 1e3),
images: array(
imageSchema,
),
});
parseOrThrow(
definitionToSchema({
id: float,
created: date,
title: string
.with(nonEmpty)
.with(maxLength, 100),
brand: string
.with(nonEmpty)
.with(maxLength, 30),
description: string
.with(nonEmpty)
.with(maxLength, 500),
price: float
.with(gte, 1)
.with(lte, 1e4),
discount: float
.with(gte, 1)
.with(lte, 100)
.with(nullable2),
quantity: float
.with(gte, 0)
.with(lte, 10),
tags: array(
string
.with(nonEmpty)
.with(maxLength, 30),
),
images: array(
imageSchema,
),
ratings: array(
ratingSchema,
),
}),
)({});
var pathEmpty = [];
var pathDynamic = ["[]"];
var inlineUnsafeRe = /["\\\n\r]/;
var inlinedValueFromString = (str) =>
inlineUnsafeRe.test(str)
? JSON.stringify(str)
: `"${str}"`;
var jsIdentRe = /^[A-Za-z_$][\w$]*$/;
var inlinedObjectKey = (key) =>
key === "__proto__"
? '["__proto__"]'
: jsIdentRe.test(key)
? key
: inlinedValueFromString(key);
var inlinedProperty = (obj, key, numeric) =>
numeric && /^\d+$/.test(key)
? `${obj}[${key}]`
: key === "__proto__" || !jsIdentRe.test(key)
? `${obj}[${inlinedValueFromString(key)}]`
: `${obj}.${key}`;
var pathConcat = (
path,
concatedPath,
) =>
path.length
? concatedPath.length
? path.concat(concatedPath)
: path
: concatedPath;
var pathToText = (path) => {
let text = "";
for (let idx = 0; idx < path.length; idx++) {
const segment = path[idx];
text +=
typeof segment !== "string"
? `[${String(segment)}]`
: /^\d+$/.test(segment)
? `[${segment}]`
: segment === "[]"
? segment
: jsIdentRe.test(segment)
? text
? `.${segment}`
: segment
: `[${inlinedValueFromString(segment)}]`;
}
return text;
};
var stringTag = "string";
var numberTag = "number";
var bigintTag = "bigint";
var booleanTag = "boolean";
var symbolTag = "symbol";
var nullTag = "null";
var undefinedTag = "undefined";
var nanTag = "nan";
var functionTag = "function";
var instanceTag = "instance";
var arrayTag = "array";
var objectTag = "object";
var anyOfTag = "anyOf";
var neverTag = "never";
var unknownTag = "unknown";
var refTag = "ref";
var tagFlags = {
[unknownTag]: 1,
[stringTag]: 2,
[numberTag]: 4,
[booleanTag]: 8,
[undefinedTag]: 16,
[nullTag]: 32,
[objectTag]: 64,
[arrayTag]: 128,
[anyOfTag]: 256,
[refTag]: 512,
[bigintTag]: 1024,
[nanTag]: 2048,
[functionTag]: 4096,
[instanceTag]: 8192,
[neverTag]: 32768,
[symbolTag]: 16384,
};
var vendor = "sury";
var s = Symbol(vendor);
vendor + "";
var U = void 0;
var immutableEmptyArray = [];
var immutableEmptyObject =
Object.create(null);
var isSchemaObject = (obj) =>
typeof obj === objectTag &&
obj !== null &&
"~standard" in obj;
var isLiteral = (schema) => "const" in schema;
var isOptional = (schema) =>
schema.type === undefinedTag ||
(schema.type === anyOfTag && undefinedTag in schema.has);
var namedConstructor = (unknown2) => {
const ctor = Object.getPrototypeOf(unknown2)?.constructor;
return ctor !== Object && ctor?.name;
};
var stringifyLeaf = (unknown2) => {
const tagFlag = tagFlags[typeof unknown2];
if (tagFlag & 16) return undefinedTag;
else if (tagFlag & 4160)
return unknown2 === null
? nullTag
: Array.isArray(unknown2)
? `Array(${unknown2.length})`
: namedConstructor(unknown2) || objectTag;
else if (tagFlag & 2) return `"${unknown2}"`;
else if (tagFlag & 1024) return `${unknown2}n`;
else return unknown2.toString();
};
var stringify = (unknown2) => {
if (unknown2 !== null && typeof unknown2 === objectTag) {
if (Array.isArray(unknown2)) {
const items = unknown2;
let body = "";
for (let idx = 0; idx < items.length; idx++) {
if (idx === 5) {
body += ", ...";
break;
}
body +=
(idx ? ", " : "") + stringifyLeaf(items[idx]);
}
return `[${body}]`;
}
if (!namedConstructor(unknown2)) {
const dict2 = unknown2;
let body = "";
let count = 0;
for (const key in dict2) {
if (count++ === 5) {
body += "... ";
break;
}
body +=
key + ": " + stringifyLeaf(dict2[key]) + "; ";
}
return body ? `{ ${body}}` : "{}";
}
}
return stringifyLeaf(unknown2);
};
var inputExpression = (
schema,
skipOverride,
) => {
if (schema.name) return schema.name;
else if (schema.const !== U)
return stringify(schema.const);
else if (schema.expression && !skipOverride)
return schema.expression(schema);
else if (schema.anyOf !== U) {
const anyOf = schema.anyOf;
const seen = new Set();
let body = "";
for (let idx = 0; idx < anyOf.length; idx++) {
const expression = inputExpression(
anyOf[idx],
);
if (!seen.has(expression)) {
seen.add(expression);
body += (body ? " | " : "") + expression;
}
}
return body;
} else if (schema.type === objectTag) {
const properties = schema.properties;
const additionalItems = schema.additionalItems;
let body = "";
for (const location in properties)
body +=
location +
": " +
inputExpression(
properties[location],
) +
"; ";
if (typeof additionalItems === objectTag)
body +=
"[key: string]: " +
inputExpression(additionalItems) +
"; ";
return body ? `{ ${body}}` : "{}";
} else if (schema.type === arrayTag) {
const additionalItems = schema.additionalItems;
if (typeof additionalItems === objectTag) {
const item = additionalItems;
const itemName =
inputExpression(item);
return (
(item.type === anyOfTag ||
item.bounds !== U ||
item.multipleOf !== U
? `(${itemName})`
: itemName) + "[]"
);
}
const items = schema.items;
let body = "";
for (let idx = 0; idx < items.length; idx++)
body +=
(idx ? ", " : "") +
inputExpression(items[idx]);
return `[${body}]`;
} else if (schema.format) return schema.format;
else if (schema.type === instanceTag)
return schema.class.name;
else return schema.type;
};
var Schema = function () {};
var schemaPrototype = Object.create(null);
Object.defineProperty(schemaPrototype, "with", {
value(fn, ...args) {
return fn(this, ...args);
},
});
Schema.prototype = schemaPrototype;
var reversedKey = "r";
var SelfReverseSchema = function () {};
var selfReversePrototype = Object.create(schemaPrototype);
Object.defineProperty(selfReversePrototype, reversedKey, {
get() {
return this;
},
});
Object.defineProperty(selfReversePrototype, "sr", {
value: true,
});
SelfReverseSchema.prototype = selfReversePrototype;
var isOwnSchema = (value) => {
const proto =
typeof value === objectTag &&
value &&
Object.getPrototypeOf(value);
return (
proto === schemaPrototype ||
proto === selfReversePrototype
);
};
var panicNotSchema = () => panic("Expected a Sury schema");
var seq = 1;
var exnId = {};
var SuryError = class extends Error {
constructor(params) {
super();
Object.assign(this, params);
}
get message() {
return formatErrorMessage(this);
}
get _1() {
return this;
}
get RE_EXN_ID() {
return exnId;
}
};
Object.defineProperty(SuryError.prototype, "name", {
value: "SuryError",
});
Object.defineProperty(SuryError.prototype, "s", {
value: s,
});
var getOrRethrow = (exn) => {
if (exn && exn.s === s) return exn;
throw exn;
};
var panic = (message) => {
throw new Error(`[Sury] ${message}`);
};
var formatErrorMessage = (error) =>
`${error.path.length ? `Failed at ${/* @__PURE__ */ pathToText(error.path)}: ` : ""}${error.reason}`;
var globalConfig = {
m: formatErrorMessage,
d: U,
a: "strip",
f: 0,
};
var valueOptions = {};
var configurableValueOptions = { configurable: true };
var valKey = "value";
var baseSchema = (tag, selfReverse, decoder) => {
const schema = new (
selfReverse ? SelfReverseSchema : Schema
)();
schema.type = tag;
schema.seq = seq++;
schema.decoder = decoder;
return schema;
};
var noopDecoder = (input) => input;
var initSchema = (
tag,
decoder,
init,
) => {
const schema = baseSchema(tag, true, decoder);
return (init?.(schema), schema);
};
var unknown = baseSchema(unknownTag, true, noopDecoder);
var copySchema = (schema) => {
const c = Object.assign(new Schema(), schema);
c.seq = seq++;
if (schema.content !== U) setContent(c, schema.content);
if (schema.bc !== U) setBytesCodec(c, schema.bc);
return c;
};
var copyTo = (from, to2) => {
const mut = copySchema(from);
mut.to = to2;
return mut;
};
var setContent = (schema, content) => {
valueOptions[valKey] = content;
Object.defineProperty(schema, "content", valueOptions);
};
var setBytesCodec = (schema, codec) => {
valueOptions[valKey] = codec;
Object.defineProperty(schema, "bc", valueOptions);
};
var updateOutput = (schema, fn) => {
const root = copySchema(schema);
let mut = root;
while (mut.to) {
const next = copySchema(mut.to);
mut.to = next;
mut = next;
}
fn(mut);
return root;
};
var setHas = (has, tag) => {
has[tagFlags[tag] & 768 ? unknownTag : tag] = true;
};
function _var() {
return this.i;
}
var _linkVar = function () {
return (this.b || this.prev).v();
};
function _notVarBeforeValidation() {
const val = this;
const v = B_varWithoutAllocation(val.g);
val.cp = `let ${v}=${val.i};`;
val.i = v;
val.v = _var;
return v;
}
function _notVarAtParent() {
const val = this;
const parent = val.p;
if (parent.fz) {
val.v = _var;
return val.i;
}
const v = B_varWithoutAllocation(val.g);
B_hoistDecl(parent, `${v}=${val.i}`);
val.v = _var;
val.i = v;
return v;
}
function _notVar() {
const val = this;
if (val.fz) {
val.v = _var;
val.i = `(${val.i})`;
return val.i;
}
const v = B_varWithoutAllocation(val.g);
if (val.prev !== U) {
if (val.i === "") val.cp = `let ${v};` + val.cp;
else val.cp += `let ${v}=${val.i};`;
} else
B_hoistDecl(val, val.i === "" ? v : `${v}=${val.i}`);
val.v = _var;
val.i = v;
return v;
}
var operationArgVar = "i";
var failInvalidType = (input) => {
const em = input.e.errorMessage;
return B_invalidInputBuilder(
U,
U,
em &&
(input.e.format !== U && em.format !== U
? em.format
: em.type !== U
? em.type
: em._),
)(input);
};
var B_embed = (b, value) => (
b.g.t++,
B_embedPure(b, value)
);
var B_embedPure = (b, value) =>
`e[${b.g.e.push(value) - 1}]`;
var B_inlineConst = (b, schema) => {
const tagFlag = tagFlags[schema.type],
const_ = schema.const;
return tagFlag & 16
? "void 0"
: tagFlag & 2
? inlinedValueFromString(const_)
: tagFlag & 1024
? const_ + "n"
: tagFlag & 28672
? B_embedPure(b, schema.const)
: const_;
};
var B_varWithoutAllocation = (g) => `v${++g.v}`;
var B_hoistDecl = (owner, decl) => {
owner.hd += (owner.hd && ",") + decl;
};
var B_operationArg = (schema, expected, flag, defs) => {
return {
b: U,
p: U,
v: _var,
i: operationArgVar,
s: schema,
io: U,
e: expected,
prev: U,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathEmpty,
g: {
d: defs,
o: flag,
e: [],
v: -1,
t: 0,
},
o: U,
};
};
var B_throw = (errorDetails) => {
throw new SuryError(errorDetails);
};
var B_unsupportedDecode = (b, from, target) =>
B_throw({
code: "unsupported_decode",
from,
to: target,
reason: `Can't decode ${/* @__PURE__ */ inputExpression(from)} -> ${/* @__PURE__ */ inputExpression(target)}. Define custom codec with S.to`,
path: b.path,
});
var B_failWithArg = (b, fn, arg) =>
`${B_embed(b, (a) => {
B_throw(fn(a));
})}(${arg})`;
var B_markThrow = (b) => {
b.g.t++;
};
var B_foreignDetails = (input, to2, cause) => ({
code: "invalid_conversion",
from: input.s,
to: to2,
cause,
path: input.path,
reason:
cause instanceof Error
? ("" + cause).replace(/^Error: /, "")
: stringify(cause),
});
var B_errorOf = (input) => {
let to2 = input.e;
while (to2.to) to2 = to2.to;
return (e) =>
e && e.s === s
? e
: new SuryError(B_foreignDetails(input, to2, e));
};
var B_makeInvalidInputDetails = (
expected,
received,
path,
input,
unionErrors,
reasonOverride,
) => {
let reasonRef = reasonOverride;
if (reasonRef === U) {
const expectedExpression =
inputExpression(expected);
const receivedExpression = stringify(input);
reasonRef = `Expected ${expectedExpression}, received ${expectedExpression === receivedExpression ? "invalid " : ""}${receivedExpression}`;
}
if (unionErrors) {
const seenReasons = new Set();
for (let idx = 0; idx < unionErrors.length; idx++) {
const caseError = unionErrors[idx];
const line = `
- ${caseError.path.length ? `At ${/* @__PURE__ */ pathToText(caseError.path)}: ` : ""}${caseError.reason.split("\n").join("\n ")}`;
if (!seenReasons.has(line)) {
seenReasons.add(line);
reasonRef += line;
}
}
}
return {
code: "invalid_input",
expected,
received,
path,
reason: reasonRef,
unionErrors,
input,
};
};
var B_invalidInputBuilder =
(expected, extraPath = pathEmpty, reasonOverride) =>
(input) => {
const path = pathConcat(
input.path,
extraPath,
);
return (value) =>
B_makeInvalidInputDetails(
expected ?? input.e,
(input.prev || input).s,
path,
value,
U,
reasonOverride,
);
};
var B_failWithErrorMessage =
(key, defaultMessage) => (input) => {
const em = input.e.errorMessage;
const m = em?.[key] ?? em?.["_"] ?? defaultMessage;
return m !== U
? B_invalidInputBuilder(U, U, m)(input)
: failInvalidType(input);
};
var B_embedInvalidInput = (input, expected = input.e) =>
B_failWithArg(
input,
B_invalidInputBuilder(expected)(input),
input.v(),
);
var B_emitChecks = (val, inputVar) => {
const checks = val.vc;
let out = "",
i = 0,
len = checks.length;
while (i < len) {
const head = checks[i],
fail = head.f;
let cond = head.c(inputVar);
i++;
while (i < len && checks[i].f === fail) {
cond += "&&" + checks[i].c(inputVar);
i++;
}
out += `${cond}||${B_failWithArg(val, fail(val), inputVar)};`;
}
return out;
};
var B_merge = (val, out) => {
let current = val,
code = "";
while (current !== U) {
const val2 = current;
current = val2.prev;
let currentCode = "";
if (val2.vc) {
if (
out &&
(!val2.t || (!val2.prev.t && val2.cp === ""))
) {
const inputVar = (current || val2).v();
const checks = val2.vc;
let hoisted = "";
for (let i = 0; i < checks.length; i++) {
const check = checks[i];
const condCode = check.c(inputVar);
if (check.f === failInvalidType)
hoisted = hoisted
? `${hoisted}&&${condCode}`
: condCode;
else if (val2.e.noValidation !== true)
currentCode += `${condCode}||${B_failWithArg(val2, check.f(val2), inputVar)};`;
}
if (hoisted) {
out.c = out.c ? `${hoisted}&&${out.c}` : hoisted;
out.h.unshift({
v: val2,
i: inputVar,
c: hoisted,
});
}
} else if (val2.e.noValidation !== true)
currentCode = B_emitChecks(
val2,
(current || val2).v(),
);
}
if (val2.hd) currentCode += `let ${val2.hd};`;
val2.fz = true;
code = val2.cp + currentCode + code;
}
return code;
};
var B_linkVar = (val, nextVal) => {
const get = val.v.bind(val);
val.v = () => (
(nextVal.i = get()),
(nextVal.v = _var),
nextVal.i
);
};
var B_next = (prev, initial, schema, expected = prev.e) => {
return {
b: U,
p: U,
v: _notVar,
i: initial,
s: schema,
io: U,
e: expected,
prev,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: true,
path: prev.path,
g: prev.g,
o: U,
};
};
var B_refine = (
val,
schema = val.s,
checks,
expected = val.e,
) => {
const shouldLink = val.v !== _var;
const nextVal = {
b: U,
p: U,
v: shouldLink ? _linkVar : _var,
i: val.i,
s: schema,
io: U,
e: expected,
prev: val,
f: val.f,
d: val.d,
fv: U,
cp: "",
hd: "",
fz: U,
vc: checks,
u: U,
t: val.t,
path: val.path,
g: val.g,
o: U,
};
if (shouldLink) B_linkVar(val, nextVal);
return nextVal;
};
var B_pushCheck = (val, check) => {
(val.vc ?? (val.vc = [])).push(check);
};
var B_markOutput = (val, valInput) => {
let outC;
const ir = valInput.e.inputRefiner;
if (ir) {
const c = ir(valInput);
if (c.length)
(valInput.vc ?? (valInput.vc = [])).push(...c);
}
const rf = val.e.refiner;
if (rf) {
const c = rf(val);
if (c.length) outC = c;
}
if (outC && val.f & 1) {
const v = val.v();
val.i = `${v}.then(${v}=>{${B_merge(B_refine(B_scope(val), U, outC))}return ${v}})`;
val.v = _notVar;
} else if (outC) val = B_refine(val, U, outC);
val.io = true;
return val;
};
var B_hoistChildChecks = (parent, child, key) => {
const checks = child.vc;
if (checks) {
const accessor = inlinedProperty(
"",
key,
parent.s.type === arrayTag,
);
for (let i = 0; i < checks.length; i++) {
const check = checks[i];
B_pushCheck(parent, {
c: (v) => check.c(v + accessor),
f: check.f,
});
}
child.vc = U;
}
};
var B_dynamicScope = (from, locationVar) => {
const schemaAdditionalItems = from.s.additionalItems;
const expectedAdditionalItems = from.e.additionalItems;
return {
b: U,
p: from,
v: _notVarBeforeValidation,
i: `${from.v()}[${locationVar}]`,
s:
schemaAdditionalItems !== U &&
typeof schemaAdditionalItems !== "string"
? schemaAdditionalItems
: unknown,
io: U,
e:
expectedAdditionalItems !== U &&
typeof expectedAdditionalItems !== "string"
? expectedAdditionalItems
: unknown,
prev: U,
f: from.f,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathEmpty,
g: from.g,
o: U,
};
};
var B_nextConst = (from, schema, expected) =>
B_next(
from,
B_inlineConst(from, schema),
schema,
expected,
);
var B_nextVar = (
input,
schema = input.e,
expected = schema,
) => {
const output = B_next(
input,
B_varWithoutAllocation(input.g),
schema,
expected,
);
output.v = _var;
return output;
};
var B_nextVarOutput = (
input,
initial,
schema,
expected = schema,
) => {
const output = B_next(input, initial, schema, expected);
output.v = _var;
output.io = true;
return output;
};
var B_asyncVal = (from, initial) => {
const v = B_next(from, initial, from.s);
v.f = 1;
return v;
};
var B_addObjectField = (objectVal, location, val) => {
if (objectVal.s.type === arrayTag)
objectVal.s.items.push(val.s);
else {
if (!val.o) objectVal.s.required.push(location);
objectVal.s.properties[location] = val.s;
}
if (val.f & 1) val.v();
objectVal.cp += B_merge(val);
objectVal.d[location] = val;
};
var B_addKey = (objVal, key, value) =>
`${objVal.v()}[${key}]=${value.i}`;
var B_scope = (val) => {
const shouldLink = val.v !== _var;
const nextVal = {
b: val,
p: U,
v: shouldLink ? _linkVar : _var,
i: val.i,
s: val.s,
io: val.io,
e: val.e,
prev: U,
f: 0,
d: val.d,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: false,
t: false,
path: val.path,
g: val.g,
o: U,
};
if (shouldLink) B_linkVar(val, nextVal);
return nextVal;
};
var B_neverSlot = (input) =>
B_invalidOperation(
input,
`Nothing decodes ${/* @__PURE__ */ inputExpression(input.e)} -> ${/* @__PURE__ */ inputExpression(input.e.to)}. It is marked with S.never`,
);
var B_invalidOperation = (val, description) =>
B_throw({
code: "invalid_operation",
reason: description,
path: val.path,
});
var B_mergeWithCatch = (
val,
catchFn,
appendSafe,
pureSince,
) => {
const valCode = B_merge(val);
const pure = pureSince !== U && val.g.t === pureSince;
if ((valCode === "" || pure) && !(val.f & 1))
return appendSafe
? valCode + appendSafe()
: pure
? ""
: valCode;
const errorVar = B_varWithoutAllocation(val.g);
B_markThrow(val);
const catchCode = `${catchFn(errorVar)};throw ${errorVar}`;
if (val.f & 1)
val.i = `${val.i}.catch(${errorVar}=>{${catchCode}})`;
return `try{${valCode}${appendSafe ? appendSafe() : ""}}catch(${errorVar}){${catchCode}}`;
};
var B_mergeWithPathPrepend = (
val,
parent,
locationVar,
appendSafe,
pureSince,
) =>
!val.path.length && locationVar === U
? B_merge(val)
: B_mergeWithCatch(
val,
(errorVar) => {
let segments = "";
for (
let idx = 0;
idx < parent.path.length;
idx++
) {
const segment = parent.path[idx];
segments += `${typeof segment === "string" ? inlinedValueFromString(segment) : segment},`;
}
if (locationVar !== U)
segments += `${locationVar},`;
return `${errorVar}.path=[${segments}...${errorVar}.path]`;
},
appendSafe,
pureSince,
);
var noopOperation = (i) => i;
noopOperation["embedded"] = immutableEmptyArray;
var int32FormatValidation = (inputVar) =>
`${inputVar}<=2147483647&&${inputVar}>=-2147483648&&${inputVar}%1==0`;
var integerFormatValidation = (inputVar) =>
`${inputVar}%1==0`;
var typeofCondCache = {};
var typeofCond = (tag) =>
typeofCondCache[tag] ||
(typeofCondCache[tag] = (inputVar) =>
`typeof ${inputVar}==="${tag}"`);
var nanCond = (inputVar) => `Number.isNaN(${inputVar})`;
var isArrayCond = (inputVar) =>
`Array.isArray(${inputVar})`;
var objectTagCond = (inputVar) =>
`${typeofCond(objectTag)(inputVar)}&&${inputVar}&&!${isArrayCond(inputVar)}`;
var numberTagCond = (inputVar, allowNaN) => {
const t = typeofCond(numberTag)(inputVar);
return allowNaN ? t : `${t}&&${inputVar}==${inputVar}`;
};
var instanceofCond = (b, class_, inputVar) =>
`${inputVar} instanceof ${B_embed(b, class_)}`;
var typeofCheckCache = {};
var typeofCheck = (tag) =>
typeofCheckCache[tag] ||
(typeofCheckCache[tag] = {
c: typeofCond(tag),
f: failInvalidType,
});
var B_typeDecode = (input, tag, inputTagFlag) =>
inputTagFlag & 1
? B_refine(input, input.e, [typeofCheck(tag)])
: inputTagFlag & tagFlags[tag]
? input
: B_unsupportedDecode(input, input.s, input.e);
var numberDecoder = (input) => {
const inputTagFlag = tagFlags[input.s.type];
const expectedFormat = input.e.format;
if (inputTagFlag & 1) {
if (expectedFormat === "int32")
return B_refine(input, input.e, [
typeofCheck(numberTag),
{
c: int32FormatValidation,
f: failInvalidType,
},
]);
if (expectedFormat === "integer")
return B_refine(input, input.e, [
typeofCheck(numberTag),
{
c: integerFormatValidation,
f: failInvalidType,
},
]);
return B_refine(input, input.e, [
{
c: (v) => numberTagCond(v, !!(input.g.o & 2)),
f: failInvalidType,
},
]);
} else if (inputTagFlag & 2) {
const output = B_nextVar(input);
const inputVar = input.v();
output.cp = `let ${output.i}=+${inputVar};`;
output.vc = [
{
c: (_inputVar) =>
`${expectedFormat === "int32" ? int32FormatValidation(output.i) : expectedFormat === "integer" ? integerFormatValidation(output.i) : `${output.i}==${output.i}`}&&(${output.i}||${inputVar}.trim())`,
f: failInvalidType,
},
];
return output;
} else if (
inputTagFlag & 2048 &&
expectedFormat !== "int32" &&
expectedFormat !== "integer" &&
input.g.o & 2
)
return B_refine(input, input.e);
else if (inputTagFlag & 4) {
if (
input.s.format !== expectedFormat &&
expectedFormat === "int32"
)
return B_refine(input, input.e, [
input.s.format === U
? {
c: int32FormatValidation,
f: failInvalidType,
}
: {
c: (inputVar) =>
`${inputVar}<=2147483647&&${inputVar}>=-2147483648`,
f: failInvalidType,
},
]);
if (
expectedFormat === "integer" &&
input.s.format === U
)
return B_refine(input, input.e, [
{
c: integerFormatValidation,
f: failInvalidType,
},
]);
}
return B_typeDecode(input, numberTag, inputTagFlag);
};
var float = initSchema(
numberTag,
numberDecoder,
);
var inputToString = (input, schema = string) =>
B_next(input, `""+${input.i}`, schema);
var stringDecoderFn = (input) => {
const inputTagFlag = tagFlags[input.s.type];
if (inputTagFlag & 3132 && isLiteral(input.s)) {
const const_ = "" + input.s.const;
const schema = baseSchema(
stringTag,
false,
input.s.decoder,
);
schema.const = const_;
return B_next(input, `"${const_}"`, schema);
}
if (inputTagFlag & 1036)
return inputToString(input, input.e);
return B_typeDecode(input, stringTag, inputTagFlag);
};
var string = initSchema(
stringTag,
stringDecoderFn,
);
var literalDecoder = (input) => {
const expectedSchema = input.e;
if (expectedSchema.noValidation && !input.u)
return B_nextConst(input, expectedSchema);
else if (isLiteral(input.s)) {
if (input.s.const === expectedSchema.const)
return input;
else return B_nextConst(input, expectedSchema);
} else {
const schemaTagFlag = tagFlags[expectedSchema.type];
if (
tagFlags[input.s.type] & 2 &&
schemaTagFlag & 3132
) {
const stringConstSchema = baseSchema(
stringTag,
false,
literalDecoder,
);
stringConstSchema.const = "" + expectedSchema.const;
const stringConstVal = B_nextConst(
input,
stringConstSchema,
stringConstSchema,
);
stringConstVal.vc = [
{
c: (inputVar) =>
`${inputVar}==="${stringConstSchema.const}"`,
f: failInvalidType,
},
];
return B_nextConst(
stringConstVal,
expectedSchema,
expectedSchema,
);
} else if (schemaTagFlag & 2048)
return B_refine(input, expectedSchema, [
{
c: nanCond,
f: failInvalidType,
},
]);
else
return B_refine(input, expectedSchema, [
{
c: (inputVar) =>
`${inputVar}===${B_inlineConst(input, expectedSchema)}`,
f: failInvalidType,
},
]);
}
};
var unit = initSchema(
undefinedTag,
literalDecoder,
(s2) => {
s2.const = U;
},
);
var nullLiteral = initSchema(
nullTag,
literalDecoder,
(s2) => {
s2.const = null;
},
);
var nan = initSchema(
nanTag,
literalDecoder,
(s2) => {
s2.const = NaN;
},
);
var Literal_parse = (value) => {
if (value === null) return nullLiteral;
else {
const tag = typeof value;
if (tag === undefinedTag) return unit;
else if (tag === numberTag && Number.isNaN(value))
return nan;
else if (tag === objectTag) {
const s2 = baseSchema(
instanceTag,
true,
literalDecoder,
);
s2.class = value["constructor"];
s2.const = value;
return s2;
} else {
const s2 = baseSchema(tag, true, literalDecoder);
s2.const = value;
return s2;
}
}
};
var parse = (input) => {
let result = input;
let appliedEncoderRef = U;
let loopCount = 0;
while (!result.io || result.e.to) {
const appliedEncoder = appliedEncoderRef;
appliedEncoderRef = U;
const loopInput = result;
if (++loopCount > 50) panic("Loop count exceeded 50");
const defs = loopInput.e["$defs"];
if (defs)
loopInput.g.d
? Object.assign(loopInput.g.d, defs)
: (loopInput.g.d = defs);
if (loopInput.f & 1) {
const operationInputVar = loopInput.v();
const operationInput = B_scope(loopInput);
const operationOutput = parse(operationInput);
const operationCode = B_merge(operationOutput);
result =
operationInput.i !== operationOutput.i ||
operationCode !== ""
? B_next(
loopInput,
`${operationInputVar}.then(${operationInputVar}=>{${operationCode}return ${operationOutput.i}})`,
operationOutput.s,
operationOutput.e,
)
: B_refine(
loopInput,
operationOutput.s,
U,
operationOutput.e,
);
result.f |= 1;
result.io = true;
} else if (loopInput.io) {
const to2 = loopInput.e.to;
result = loopInput.e.parser
? loopInput.e.parser(loopInput)
: B_refine(result, U, U, to2);
} else {
const maybeEncoder = loopInput.s.encoder;
if (
maybeEncoder &&
maybeEncoder !== appliedEncoder &&
loopInput.s !== loopInput.e &&
loopInput.e.type !== unknownTag &&
!(
loopInput.e.noValidation &&
(loopInput.e.isJson ||
loopInput.e.type === undefinedTag)
)
)
result = maybeEncoder(loopInput, loopInput.e);
if (loopInput !== result)
appliedEncoderRef = maybeEncoder;
else {
result = loopInput.e.decoder(loopInput);
if (!result.io)
result = B_markOutput(result, result);
}
}
}
return result;
};
var parseDynamic = (input) => {
try {
return parse(input);
} catch (exn) {
const error = getOrRethrow(exn);
error.path = pathConcat(
input.p ? input.p.path : pathEmpty,
pathConcat(
pathConcat(input.path, pathDynamic),
error.path,
),
);
throw error;
}
};
var throwTail = (
input,
code,
out,
isAsync,
flag,
hasDefs,
) => {
if (flag & 1024) {
const errorOf = B_errorOf(input);
const issues = B_embedPure(input, (e2) => {
const error = errorOf(e2);
return {
issues: [
{
message: error.reason,
path: error.path.length ? error.path : U,
},
],
};
});
const v = isAsync
? B_varWithoutAllocation(input.g)
: "";
const body = isAsync
? `${code}return ${out}.then(${v}=>({value:${v}}),${issues})`
: `${code}return {value:${out}}`;
if (!input.g.t) return body;
const e = B_varWithoutAllocation(input.g);
return `try{${body}}catch(${e}){return ${isAsync ? `Promise.resolve(${issues}(${e}))` : `${issues}(${e})`}}`;
}
return code === "" &&
out === operationArgVar &&
!(flag & 1)
? U
: `${code}return ${flag & 1 && !isAsync && !hasDefs ? `Promise.resolve(${out})` : out}`;
};
var emitTail = throwTail;
var compileDecoder = (
schema,
expected,
flag,
defs,
node,
) => {
const input = B_operationArg(
isLiteral(schema) ? unknown : schema,
expected,
flag,
defs,
);
const output = parse(input);
const code = B_merge(output);
const isAsync = !!(output.f & 1);
if (node) {
node.y = isAsync;
node.t = output.t === true;
}
const body = emitTail(
input,
code,
output.i,
isAsync,
flag,
!!defs,
);
if (!body) return noopOperation;
const fn = new Function(
"e",
"s",
`return ${operationArgVar}=>{${body}}`,
)(input.g.e, s);
fn.embedded = input.g.e;
return fn;
};
var getOutputSchema = (schema) => {
while (schema.to) schema = schema.to;
return schema;
};
var reverseSwap = (mut, a, b) => {
const previous = mut[a];
mut[b] === U ? delete mut[a] : (mut[a] = mut[b]);
previous === U ? delete mut[b] : (mut[b] = previous);
};
var reverseDict = (dict2) => {
const reversed = Object.create(null);
for (const key in dict2)
reversed[key] = reverse(dict2[key]);
return reversed;
};
Object.defineProperty(schemaPrototype, reversedKey, {
get() {
const schema = this;
let reversedHead = U;
let current = schema;
while (current) {
const mut = copySchema(current);
const next = mut.to;
reversedHead
? (mut.to = reversedHead)
: delete mut.to;
const record = mut;
reverseSwap(record, "parser", "serializer");
reverseSwap(record, "refiner", "inputRefiner");
next && next.opens !== U
? (mut.opens = !next.opens)
: delete mut.opens;
delete record["default"];
delete record["examples"];
if (mut.items) mut.items = mut.items.map(reverse);
if (mut.properties)
mut.properties = reverseDict(mut.properties);
if (typeof mut.additionalItems === objectTag)
mut.additionalItems = reverse(
mut.additionalItems,
);
if (mut.anyOf) {
const anyOf = mut.anyOf;
const has = {};
const newAnyOf = [];
for (let idx = 0; idx < anyOf.length; idx++) {
const s2 = anyOf[idx];
const reversed = reverse(s2);
newAnyOf.push(reversed);
setHas(has, reversed.type);
}
mut.has = has;
mut.anyOf = newAnyOf;
}
if (mut["$defs"])
mut["$defs"] = reverseDict(mut["$defs"]);
reversedHead = mut;
current = next;
}
const r = reversedHead;
valueOptions[valKey] = r;
Object.defineProperty(
schema,
reversedKey,
valueOptions,
);
valueOptions[valKey] = schema;
Object.defineProperty(r, reversedKey, valueOptions);
return r;
},
});
var reverse = (schema) =>
schema.r;
var memoKey = "c";
var addOpNode = (schema, a, f, v) => {
const created = {
a,
f,
v,
n: schema[memoKey],
};
configurableValueOptions[valKey] = created;
Object.defineProperty(
schema,
memoKey,
configurableValueOptions,
);
return created;
};
var compileChain = (cacheTarget, args, flag) => {
let schema = args[args.length - 1];
for (let i = args.length - 2; i >= 0; i--) {
const to2 = schema;
schema = updateOutput(args[i], (mut) => {
mut.to = to2;
if (mut.content !== U && mut.opens === U)
mut.opens = true;
});
}
const f = compileDecoder(
flag & 8 ? unknown : schema,
schema,
flag,
U,
);
addOpNode(cacheTarget, args, flag, f);
return f;
};
var getOp = (
opFlag,
n,
a0,
a1,
a2,
a3,
) => {
const flag = opFlag | globalConfig.f;
let cacheTarget = a0;
let seq2 = a0.seq;
if (n > 1) {
if (a1.seq > seq2)
((seq2 = a1.seq), (cacheTarget = a1));
if (n > 2) {
if (a2.seq > seq2)
((seq2 = a2.seq), (cacheTarget = a2));
if (n > 3 && a3.seq > seq2) cacheTarget = a3;
}
}
let node = cacheTarget[memoKey];
while (node) {
const a = node.a;
if (
node.f === flag &&
a.length === n &&
a[0] === a0 &&
(n < 2 || a[1] === a1) &&
(n < 3 || a[2] === a2) &&
(n < 4 || a[3] === a3)
)
return node.v;
node = node.n;
}
return compileChain(
cacheTarget,
[a0, a1, a2, a3].slice(0, n),
flag,
);
};
var nestedLoc = "BS_PRIVATE_NESTED_SOME_NONE";
var never_ = initSchema(
neverTag,
(input) => {
const output = B_refine(input, never_, U, never_);
output.cp = B_embedInvalidInput(input) + ";";
return output;
},
);
var instanceDecoder = (input) => {
const inputTagFlag = tagFlags[input.s.type];
return inputTagFlag & 1
? B_refine(input, input.e, [
{
c: (v) => instanceofCond(input, input.e.class, v),
f: failInvalidType,
},
])
: inputTagFlag & 8192 && input.s.class === input.e.class
? input
: B_unsupportedDecode(input, input.s, input.e);
};
var typeCheckCond = (input, schema, inputVar) => {
const tagFlag = tagFlags[schema.type];
if (tagFlag & 64) return objectTagCond(inputVar);
if (tagFlag & 128) return isArrayCond(inputVar);
if (tagFlag & 8192)
return instanceofCond(input, schema.class, inputVar);
if (tagFlag & 4)
return numberTagCond(inputVar, !!(input.g.o & 2));
if (tagFlag & 2048) return nanCond(inputVar);
if (tagFlag & 48)
return `${inputVar}===${B_inlineConst(input, schema)}`;
if (tagFlag & 17418)
return schema.format === "env"
? `(typeof ${inputVar}==="string"||${inputVar}===void 0)`
: typeofCond(schema.type)(inputVar);
return "";
};
var isItemSchema = (x) => x !== U && typeof x !== "string";
var B_unrecognizedKeys = (input, keys, keyVar, decl) => {
const fail = B_failWithArg(
input,
(key) => ({
code: "unrecognized_key",
path: input.path,
reason: `Unrecognized key ${stringify(key)}`,
key,
}),
keyVar,
);
let cond = "";
for (let idx = 0; idx < keys.length; idx++) {
if (idx) cond += "&&";
cond += `${keyVar}!==${inlinedValueFromString(keys[idx])}`;
}
return (
`for(${decl}${keyVar} in ${input.v()})` +
(cond ? `if(${cond})` : "") +
fail +
";"
);
};
var B_fused = (input, expectedSchema, item) => {
const to2 = expectedSchema.to;
return to2 !== U && to2.fz !== U
? to2.fz(input, expectedSchema, item)
: U;
};
var B_narrowJsonSourcedJsonString = (itemInput) => {
if (itemInput.s.isJson && itemInput.e.format === "json")
itemInput.s = unknown;
};
var B_makeContainerVal = (prev, schema) => ({
b: U,
p: U,
v: _notVar,
i: "",
s: schema,
io: U,
e: prev.e,
prev,
f: 0,
d: Object.create(null),
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: true,
path: prev.path,
g: prev.g,
o: U,
});
var makeObjectVal = (prev) =>
B_makeContainerVal(prev, {
type: objectTag,
required: [],
properties: Object.create(null),
additionalItems: "strict",
decoder: objectDecoder,
});
var makeArrayVal = (prev) =>
B_makeContainerVal(prev, {
type: arrayTag,
items: [],
additionalItems: "strict",
decoder: arrayDecoder,
});
var completeObjectVal = (objectVal) => {
const isArray = objectVal.s.type === arrayTag;
let inline = "";
let promiseAllContent = "";
let optionalSettingCode = U;
const keys = Object.keys(objectVal.d);
for (let idx = 0; idx < keys.length; idx++) {
const key = keys[idx];
const val = objectVal.d[key];
if (val.f & 1) promiseAllContent += val.i + ",";
if (val.o) {
const existingFn = optionalSettingCode;
optionalSettingCode = (objectVar) => {
return (
(existingFn === U ? "" : existingFn(objectVar)) +
(key === "__proto__"
? `if(${val.v()}!==void 0){${objectVar}={...${objectVar},["__proto__"]:${val.i}}}`
: `if(${val.v()}!==void 0){${inlinedProperty(objectVar, key, isArray)}=${val.i}}`)
);
};
} else
inline =
inline +
(isArray
? `${val.i}`
: `${inlinedObjectKey(key)}:${val.i}`) +
",";
}
objectVal.i = isArray
? "[" + inline.slice(0, -1) + "]"
: "{" + inline.slice(0, -1) + "}";
if (promiseAllContent) {
promiseAllContent = promiseAllContent.slice(0, -1);
const operationInput = B_scope(objectVal);
operationInput.io = true;
const operationOutput = parse(operationInput);
let operationCode = B_merge(operationOutput);
let result = operationOutput.i;
if (optionalSettingCode !== U) {
const objectVar = B_varWithoutAllocation(objectVal.g);
operationCode =
operationCode +
`let ${objectVar}=${result};` +
optionalSettingCode(objectVar);
result = objectVar;
}
if (
operationCode === "" &&
promiseAllContent === result
)
objectVal.i = result;
else
objectVal.i = `Promise.all([${promiseAllContent}]).then(([${promiseAllContent}])=>{${operationCode}return ${result}})`;
objectVal.f |= 1;
objectVal.s = operationOutput.s;
objectVal.e = operationOutput.e;
objectVal.io = true;
return objectVal;
} else if (optionalSettingCode === U) return objectVal;
else {
const code = optionalSettingCode(objectVal.v());
const output = B_refine(objectVal);
output.cp = output.cp + code;
return output;
}
};
var arrayFactory = (item) => {
const mut = baseSchema(arrayTag, !!item.sr, arrayDecoder);
mut.additionalItems = item;
mut.items = immutableEmptyArray;
return mut;
};
var array = (item) =>
arrayFactory( definitionToSchema(item));
var arrayDecoder = (unknownInput) => {
const isUnion = unknownInput.u;
const expectedSchema = unknownInput.e;
const unknownInputTagFlag = tagFlags[unknownInput.s.type];
const expectedItems = expectedSchema.items;
const expectedLength = expectedItems.length;
let input;
if (unknownInputTagFlag & 129) {
const isArrayInput = unknownInputTagFlag & 128;
let schema;
if (!isArrayInput) schema = arrayFactory(unknown);
else schema = unknownInput.s;
const checks = [];
if (!isArrayInput)
checks.push({
c: isArrayCond,
f: failInvalidType,
});
const schemaAdditionalItems = schema.additionalItems;
if (
!(isItemSchema(schemaAdditionalItems)
? false
: schema.items.length === expectedLength)
) {
const expectedAdditionalItems2 =
expectedSchema.additionalItems;
if (expectedAdditionalItems2 === "strict")
checks.push({
c: (inputVar) =>
`${inputVar}.length===${expectedLength}`,
f: failInvalidType,
});
else if (expectedAdditionalItems2 === "strip")
checks.push({
c: (inputVar) =>
`${inputVar}.length>=${expectedLength}`,
f: failInvalidType,
});
}
input = B_refine(
unknownInput,
schema,
checks.length ? checks : U,
);
} else
input = B_unsupportedDecode(
unknownInput,
unknownInput.s,
expectedSchema,
);
let output;
const expectedAdditionalItems =
expectedSchema.additionalItems;
if (isItemSchema(expectedAdditionalItems)) {
const itemSchema = expectedAdditionalItems;
if (itemSchema === unknown) output = input;
else {
if (expectedLength === 0) {
const fused = B_fused(
input,
expectedSchema,
itemSchema,
);
if (fused !== U)
return B_markOutput(
B_refine(input, fused),
input,
);
}
const inputVar = input.v();
const iteratorVar = B_varWithoutAllocation(input.g);
const raiseCountBefore = input.g.t;
const itemInput = B_dynamicScope(input, iteratorVar);
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parseDynamic(itemInput);
const hasTransform = itemOutput.t;
const output2 = hasTransform
? B_next(
input,
`new Array(${inputVar}.length)`,
arrayFactory(itemOutput.s),
)
: B_refine(input, expectedSchema);
const itemCode = B_mergeWithPathPrepend(
itemOutput,
input,
iteratorVar,
hasTransform
? () => B_addKey(output2, iteratorVar, itemOutput)
: U,
hasTransform ? U : raiseCountBefore,
);
if (hasTransform || itemCode !== "")
output2.cp =
output2.cp +
`for(let ${iteratorVar}=${expectedLength};${iteratorVar}<${inputVar}.length;++${iteratorVar}){${itemCode}}`;
if (itemOutput.f & 1)
output = B_asyncVal(
output2,
`Promise.all(${output2.i})`,
);
else output = output2;
}
} else {
const objectVal = makeArrayVal(input);
const fused = B_fused(input, expectedSchema);
const ai = expectedSchema.additionalItems;
let shouldRecreateInput =
fused === U &&
ai !== "strict" &&
(ai !== "strip" ||
isItemSchema(input.s.additionalItems) ||
input.s.items.length !== expectedLength);
for (let idx = 0; idx < expectedLength; idx++) {
const schema = expectedItems[idx];
const key = String(idx);
const itemInput = valGet(input, key);
itemInput.e = schema;
itemInput.io = false;
itemInput.u = isUnion;
if (fused !== U && !(isUnion && isLiteral(schema))) {
B_addObjectField(objectVal, key, itemInput);
continue;
}
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parse(itemInput);
if (isUnion && isLiteral(schema))
B_hoistChildChecks(input, itemOutput, key);
B_addObjectField(objectVal, key, itemOutput);
if (!shouldRecreateInput)
shouldRecreateInput = itemOutput.t;
}
if (shouldRecreateInput)
output = completeObjectVal(objectVal);
else {
const o = B_refine(input, fused || expectedSchema);
o.cp = objectVal.cp;
o.d = objectVal.d;
output = o;
}
}
return B_markOutput(output, input);
};
var objectTypeCheck = {
c: objectTagCond,
f: failInvalidType,
};
var objectDecoder = (unknownInput) => {
const isUnion = unknownInput.u;
const expectedSchema = unknownInput.e;
const unknownInputTagFlag = tagFlags[unknownInput.s.type];
let input;
if (unknownInputTagFlag & 65) {
const isObjectInput = unknownInputTagFlag & 64;
let schema;
if (!isObjectInput) {
const mut = baseSchema(
objectTag,
false,
objectDecoder,
);
mut.properties = immutableEmptyObject;
mut.additionalItems = unknown;
schema = mut;
} else schema = unknownInput.s;
input = isObjectInput
? B_refine(unknownInput, schema)
: B_refine(unknownInput, schema, [objectTypeCheck]);
} else
input = B_unsupportedDecode(
unknownInput,
unknownInput.s,
expectedSchema,
);
const expectedAdditionalItems =
expectedSchema.additionalItems;
const dictItem = isItemSchema(expectedAdditionalItems)
? expectedAdditionalItems
: U;
const inputAdditionalItems = input.s.additionalItems;
const sourceIsDict = isItemSchema(inputAdditionalItems);
let output;
if (dictItem !== U && dictItem === unknown)
output = input;
else if (dictItem !== U && sourceIsDict) {
const fused = B_fused(input, expectedSchema, dictItem);
if (fused !== U)
return B_markOutput(B_refine(input, fused), input);
const inputVar = input.v();
const keyVar = B_varWithoutAllocation(input.g);
const raiseCountBefore = input.g.t;
const itemInput = B_dynamicScope(input, keyVar);
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parseDynamic(itemInput);
const hasTransform = itemOutput.t;
const output2 = hasTransform
? B_next(input, "{}", dictFactory(itemOutput.s))
: B_refine(input, expectedSchema);
const itemCode = B_mergeWithPathPrepend(
itemOutput,
input,
keyVar,
hasTransform
? () => B_addKey(output2, keyVar, itemOutput)
: U,
hasTransform ? U : raiseCountBefore,
);
if (hasTransform || itemCode !== "")
output2.cp =
output2.cp +
`for(let ${keyVar} in ${inputVar}){${itemCode}}`;
if (itemOutput.f & 1) {
const resolveVar = B_varWithoutAllocation(output2.g);
const rejectVar = B_varWithoutAllocation(output2.g);
const asyncParseResultVar = B_varWithoutAllocation(
output2.g,
);
const counterVar = B_varWithoutAllocation(output2.g);
const outputVar = output2.v();
output = B_asyncVal(
output2,
`new Promise((${resolveVar},${rejectVar})=>{let ${counterVar}=Object.keys(${outputVar}).length;if(!${counterVar}){${resolveVar}(${outputVar})}for(let ${keyVar} in ${outputVar}){${outputVar}[${keyVar}].then(${asyncParseResultVar}=>{${outputVar}[${keyVar}]=${asyncParseResultVar};if(${counterVar}--===1){${resolveVar}(${outputVar})}},${rejectVar})}})`,
);
} else output = output2;
} else if (dictItem !== U) {
const itemSchema = dictItem;
const objectVal = makeObjectVal(input);
const keys = Object.keys(input.s.properties);
for (let idx = 0; idx < keys.length; idx++) {
const key = keys[idx];
const itemInput = valGet(input, key);
const source = itemInput.s;
const absent =
source.type === anyOfTag &&
source.has[undefinedTag] &&
!(tagFlags[itemSchema.type] & 817) &&
itemSchema.format !== "json";
if (absent) {
const target = copySchema(source);
target.anyOf = source.anyOf.map((variant) =>
variant.type === undefinedTag
? variant
: updateOutput(variant, (mut) => {
mut.to = itemSchema;
}),
);
target.perVariant = true;
itemInput.e = target;
} else itemInput.e = itemSchema;
itemInput.io = false;
itemInput.u = isUnion;
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parse(itemInput);
if (absent) itemOutput.o = true;
B_addObjectField(objectVal, key, itemOutput);
}
output = completeObjectVal(objectVal);
} else {
const properties = expectedSchema.properties;
const keys = Object.keys(properties);
const keysCount = keys.length;
const objectVal = makeObjectVal(input);
const ai = expectedSchema.additionalItems;
const fused = B_fused(input, expectedSchema);
let shouldRecreateInput =
fused === U &&
ai !== "strict" &&
(ai !== "strip" ||
sourceIsDict ||
Object.keys(input.s.properties).length !==
keysCount);
const isJsonParent =
isItemSchema(inputAdditionalItems) &&
inputAdditionalItems.isJson;
for (let idx = 0; idx < keysCount; idx++) {
const key = keys[idx];
const schema = properties[key];
const itemInput = valGet(input, key);
itemInput.e = schema;
itemInput.io = false;
itemInput.u = isUnion;
if (
isJsonParent &&
schema.type === anyOfTag &&
schema.has[undefinedTag]
)
itemInput.i = `(${itemInput.i}??null)`;
if (fused !== U && !(isUnion && isLiteral(schema))) {
B_addObjectField(objectVal, key, itemInput);
continue;
}
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parse(itemInput);
if (isUnion && isLiteral(schema))
B_hoistChildChecks(input, itemOutput, key);
B_addObjectField(objectVal, key, itemOutput);
if (!shouldRecreateInput)
shouldRecreateInput = itemOutput.t;
}
if (
ai === "strict" &&
isItemSchema(inputAdditionalItems) &&
fused === U
) {
const keyVar = B_varWithoutAllocation(objectVal.g);
B_hoistDecl(input, keyVar);
objectVal.cp += B_unrecognizedKeys(
input,
keys,
keyVar,
"",
);
}
if (shouldRecreateInput)
output = completeObjectVal(objectVal);
else {
const o = B_refine(input, fused || expectedSchema);
o.cp = objectVal.cp;
o.d = objectVal.d;
output = o;
}
}
return B_markOutput(output, input);
};
var dictFactory = (item) => {
const mut = baseSchema(
objectTag,
!!item.sr,
objectDecoder,
);
mut.properties = immutableEmptyObject;
mut.additionalItems = item;
return mut;
};
var definitionToSchema = (
definition,
) =>
isSchemaObject(definition)
? definition
: traverseDefinition(definition, (node) =>
isSchemaObject(node) ? node : U,
);
var traverseDefinition = (definition, onNode) => {
if (
typeof definition === objectTag &&
definition !== null
) {
const s2 = onNode(definition);
if (s2 !== U) return s2;
else if (Array.isArray(definition)) {
const node = definition;
for (let idx = 0; idx < node.length; idx++)
node[idx] = traverseDefinition(node[idx], onNode);
const items = node;
const mut = baseSchema(arrayTag, false, arrayDecoder);
mut.items = items;
mut.additionalItems = "strict";
return mut;
} else {
const proto = Object.getPrototypeOf(definition);
if (proto !== null && proto !== Object.prototype) {
const mut = baseSchema(
instanceTag,
true,
literalDecoder,
);
mut.class = definition["constructor"];
mut.const = definition;
return mut;
} else {
const node = definition;
const fieldNames = Object.keys(node);
const length2 = fieldNames.length;
for (let idx = 0; idx < length2; idx++) {
const location = fieldNames[idx];
node[location] = traverseDefinition(
node[location],
onNode,
);
}
const mut = baseSchema(
objectTag,
false,
objectDecoder,
);
mut.required = fieldNames;
mut.properties = node;
mut.additionalItems = globalConfig.a;
return mut;
}
}
} else return Literal_parse(definition);
};
var missingKeyEncoder = (input, target) => {
const item = input.s.anyOf[0];
const v = input.v();
const presentIn = B_scope(input);
presentIn.io = false;
presentIn.s = item;
presentIn.e = target;
presentIn.u = true;
const presentOut = parse(presentIn);
const presentCode = B_merge(presentOut);
const presentAssign =
presentOut.i === v ? "" : `${v}=${presentOut.i};`;
const absentCode2 = isOptional(target)
? ""
: B_embedInvalidInput(input, target);
const output = B_nextVarOutput(
input,
v,
getOutputSchema(target),
target,
);
const presentBody = presentCode + presentAssign;
output.cp =
presentBody === ""
? absentCode2 === ""
? ""
: `${v}!==void 0||${absentCode2};`
: absentCode2 === ""
? `if(${v}!==void 0){${presentBody}}`
: `if(${v}!==void 0){${presentBody}}else{${absentCode2}}`;
return output;
};
var wrapDictMissingKeyLight = (s2) => {
const mut = baseSchema(anyOfTag, false, noopDecoder);
mut.anyOf = [s2, unit];
mut.has = { [undefinedTag]: true };
setHas(mut.has, s2.type);
mut.encoder = missingKeyEncoder;
mut.perVariant = true;
return mut;
};
var valGet = (parent, location) => {
const vals =
parent.d ??
(parent.d = Object.create(null));
const existing = vals[location];
if (existing !== U) return B_scope(existing);
else {
let locationSchema;
if (parent.s.type === objectTag)
locationSchema = parent.s.properties[location];
else locationSchema = parent.s.items[Number(location)];
let schema;
if (locationSchema !== U) schema = locationSchema;
else {
const additionalItems = parent.s.additionalItems;
if (isItemSchema(additionalItems)) {
const s2 = additionalItems;
if (
parent.s.type === objectTag &&
s2.type !== unknownTag &&
!(tagFlags[s2.type] & 512) &&
!isOptional(s2)
)
schema = wrapDictMissingKeyLight(s2);
else schema = s2;
} else
schema = B_unsupportedDecode(
parent,
parent.s,
parent.e,
);
}
const accessor = inlinedProperty(
"",
location,
parent.s.type === arrayTag,
);
const item = {
b: U,
p: parent,
v: _notVarAtParent,
i: isLiteral(schema)
? B_inlineConst(parent, schema)
: parent.s.type === objectTag &&
location in Object.prototype
? `(Object.hasOwn(${parent.v()},${inlinedValueFromString(location)})?${parent.v()}${accessor}:void 0)`
: `${parent.v()}${accessor}`,
s: schema,
io: U,
e: schema,
prev: U,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathConcat(parent.path, [
location,
]),
g: parent.g,
o: U,
};
vals[location] = item;
return item;
}
};
var unionRuntimeSame = (a, b) =>
a.type === b.type && a.class === b.class;
var unionSameType = (a, b) =>
a === b ||
(unionRuntimeSame(a, b) &&
!(tagFlags[a.type] & 768) &&
a.format === b.format);
var unionLiteralEqual = (a, b) =>
a === b || (a !== a && b !== b);
var unionOutput = (schema) => {
let output = schema;
while (output.type !== neverTag && output.to !== U) {
if (output.parser === B_neverSlot) return never_;
output = output.to;
}
return output;
};
var unionNeverLink = (schema) => {
for (
let node = schema;
node !== U && node.type !== neverTag;
node = node.to
)
if (node.parser === B_neverSlot) return true;
return false;
};
var unionIsTransparent = (schema) => {
if (schema.type !== anyOfTag) return false;
let fields = 0;
for (const _key in schema) fields++;
return fields === 6;
};
var unionTraits = (schema) => {
const tag = tagFlags[schema.type];
let traits = 0;
if (tag & 4864 || schema.parser !== U) return 15;
if (schema.refiner !== U || schema.inputRefiner !== U)
traits |= 3;
else if (tag & 8384) traits |= 2;
if (schema.format !== U || isLiteral(schema)) traits |= 1;
const to2 = schema.to;
if (to2 !== U) {
if (
to2 === schema ||
to2.parser !== U ||
tagFlags[to2.type] & 4864
)
traits |= 15;
else if (
!(
to2.noValidation === true ||
tagFlags[to2.type] & 1 ||
unionRuntimeSame(schema, to2) ||
(to2.type === anyOfTag &&
unionMask(to2, 1, 0) & tag)
)
)
traits |= 9;
else traits |= unionTraits(to2);
}
const fields = schema.items || schema.properties;
for (const key in fields) {
const field = fields[key];
traits |= unionTraits(field);
}
if (typeof schema.additionalItems === "object")
traits |= unionTraits(schema.additionalItems);
return traits;
};
var unionIsNoop = (schema) => {
if (
schema.to !== U ||
schema.parser !== U ||
tagFlags[schema.type] & 512
)
return false;
const fields =
schema.anyOf || schema.items || schema.properties;
for (const key in fields)
if (!unionIsNoop(fields[key])) return false;
return (
typeof schema.additionalItems !== "object" ||
unionIsNoop(schema.additionalItems)
);
};
var unionFail = (schema, path, input, ...unionErrors) =>
B_throw(
B_makeInvalidInputDetails(
schema,
unknown,
path,
input,
unionErrors.length ? unionErrors : U,
),
);
var unionEmitChain = (cases, ctx) => {
if (cases.length === 1) {
const c = cases[0];
if (c.b === "" && c.c === "") return "";
if (c.b === "") return `if(!(${c.c})){${ctx.f("")}}`;
if (c.c === "")
return c.b.endsWith(";") ? c.b : c.b + ";";
return `if(${c.c}){${c.b}}else{${ctx.f("")}}`;
}
let code = "";
let caught = false;
let exhaustive = false;
let open = false;
const attempt = (c, idx) => {
open = false;
if (c.b === "") return "break";
const body = c.b.endsWith(";") ? c.b : `${c.b};`;
if (c.f & 1 && (c.f & 8 || caught)) {
caught = open = true;
return `try{${body}break}catch(x){${c.f & 4 ? `x=${ctx.r()}(x);if(x.expected===${ctx.s()}){x=x.unionErrors;x&&(r||(r=[])).push(...x)}else{(r||(r=[])).push(x)}` : `(r||(r=[])).push(${ctx.r()}(x))`}${!(c.f & 8) && unconditional > idx ? `;${ctx.f(",...(r||[])")}` : ""}}`;
}
return `${body}break`;
};
let unconditional = -1;
for (let idx = 0; idx < cases.length; idx++)
if (cases[idx].c === "") unconditional = idx;
let last = "";
for (let idx = 0; idx < cases.length; idx++) {
const c = cases[idx];
const shared = c.c !== "" && c.c === last;
if (shared && !open) continue;
const arm = attempt(c, idx);
last = c.c;
if (shared) code = `${code.slice(0, -1)}${arm}}`;
else if (c.c === "") {
code += open ? arm : `${arm};`;
if (!open) {
exhaustive = true;
break;
}
} else
code +=
arm === "break"
? `if(${c.c})break;`
: `if(${c.c}){${arm}}`;
}
if (!exhaustive)
code += ctx.f(caught ? ",...(r||[])" : "");
return `for(;;){${caught ? "let r;" : ""}${code}}`;
};
var unionOr = (cs) => {
const s2 = cs.map((c) => c.c).join("||");
return cs.length > 1 ? `(${s2})` : s2;
};
var unionNarrowSchema = (schema) => {
const tagFlag = tagFlags[schema.type];
const container = 192;
const narrow = baseSchema(schema.type, false, (input) => {
if (tagFlags[input.s.type] & 1)
return B_refine(input, input.e, [
{
c: (inputVar) =>
typeCheckCond(input, schema, inputVar),
f: failInvalidType,
},
]);
if (unionRuntimeSame(input.s, narrow))
return tagFlag & container
? B_refine(input, input.e)
: input;
if (isLiteral(schema) && tagFlag & 1036) {
input.e = schema;
const output = schema.decoder(input);
input.e = narrow;
return output;
}
return schema.decoder(input);
});
narrow.encoder = schema.encoder;
if (schema.content !== U)
setContent(narrow, schema.content);
if (tagFlag & 8192) narrow.class = schema.class;
else if (tagFlag & container) {
narrow.additionalItems = unknown;
if (tagFlag & 64)
narrow.properties = immutableEmptyObject;
else narrow.items = immutableEmptyArray;
} else if (tagFlag & 2096) narrow.const = schema.const;
else if (
tagFlag & 2 &&
schema.format !== U &&
schema.format !== "json"
) {
narrow.format = schema.format;
narrow.formatFlag = schema.formatFlag;
narrow.noValidation = schema.noValidation;
}
return narrow;
};
var unionWiden = (tagFlag, nan2) =>
tagFlag |
(tagFlag & 8256
? 8256
: tagFlag & tagFlags[numberTag]
? nan2
: 0);
var unionRefDef = (schema) => {
const defs = schema["$defs"],
ref = schema["$ref"];
if (defs === U || ref === U) return U;
const resolved =
defs[ref.slice(ref.lastIndexOf("/") + 1)];
return resolved !== U && resolved !== schema
? resolved
: U;
};
var unionMask = (schema, mode, nan2) => {
if (mode === 2) {
const resolved = unionRefDef(schema);
if (resolved !== U) return unionMask(resolved, 1, nan2);
}
const tagFlag = tagFlags[schema.type];
if (!mode && tagFlag & 32768) return 0;
if (mode && tagFlag & 256) {
let mask = 0;
const variants = schema.anyOf;
for (let i = 0; i < variants.length; i++)
mask |= unionMask(variants[i], 1, nan2);
return mask;
}
return tagFlag & 769 ? -1 : unionWiden(tagFlag, nan2);
};
var unionGroup = (member) => ({
m: member.m,
a: [member],
f: member.f & 16,
p: member.p,
o: false,
});
var unionDiscriminator = (schema) => {
if (isLiteral(schema)) return ["", schema.const];
const fields = schema.properties || schema.items;
for (const key in fields) {
const field = fields[key];
if (isLiteral(field)) return [key, field.const];
}
return U;
};
var unionDropNullish = (variants, other, outputSide) => {
if (
other === U ||
tagFlags[other.type] & 817 ||
other.format === "json" ||
other.format === "env"
)
return variants;
const kept = variants.filter(
(variant) =>
!(
tagFlags[
(outputSide ? unionOutput(variant) : variant).type
] & 48
),
);
return kept.length ? kept : variants;
};
var unionCheckPartial = (
input,
source,
target,
variants,
outputSide,
) => {
const other = outputSide ? target : source;
let matched = U;
let unmatched = U;
for (let idx = 0; idx < variants.length; idx++) {
const variant = variants[idx];
const match = outputSide
? unionOutput(variant)
: variant;
if (
variant.type === neverTag ||
(outputSide
? match.type === neverTag
: unionNeverLink(variant))
)
continue;
if (unionSameType(other, match))
matched || (matched = variant);
else unmatched || (unmatched = variant);
}
if (matched !== U && unmatched !== U)
unionInvalid(
input,
source,
target,
unmatched,
outputSide,
);
};
var unionPeer = (schema) =>
schema.anyOf?.find(
(variant) => !(tagFlags[variant.type] & 32816),
) || schema;
var unionInvalid = (
input,
source,
target,
member,
onSource,
) => {
const it = inputExpression(member);
const conversion = onSource
? `${it} -> ${/* @__PURE__ */ inputExpression(unionPeer(target))}`
: `${/* @__PURE__ */ inputExpression(unionPeer(source))} -> ${it}`;
return B_invalidOperation(
input,
`Ambiguous ${/* @__PURE__ */ inputExpression(source)} -> ${/* @__PURE__ */ inputExpression(target)}. Should ${it} be decoded or ignored? Choose with S.to for ${conversion}, or S.never -> ${it}`,
);
};
var unionAnalyze = (
sourceMask,
flags,
sourceTag,
variants,
source,
nan2,
) => {
const out = [];
const unknownSource = sourceTag & 1;
const sourceBoundary = sourceTag & 768;
const unionSource = sourceBoundary && sourceMask !== -1;
const sourceDiscriminator = unionDiscriminator(source);
const exact = flags & 1;
const broadObject = flags & 64;
const broadNumber = flags & tagFlags[numberTag];
const numberish = tagFlags[numberTag] | 2048;
for (let i = 0; i < variants.length; i++) {
const s2 = variants[i];
const tag = tagFlags[s2.type];
const inputMask = unionMask(s2, 1, nan2);
const d = unionDiscriminator(s2);
const same = unionRuntimeSame(source, s2);
const discriminatorDisjoint =
sourceDiscriminator !== U &&
d !== U &&
same &&
sourceDiscriminator[0] === d[0] &&
!unionLiteralEqual(sourceDiscriminator[1], d[1]);
const accepts =
!(tag & 32768) &&
!unionNeverLink(s2) &&
!discriminatorDisjoint &&
(!exact ||
(isLiteral(s2)
? unionLiteralEqual(s2.const, source.const)
: sourceMask & inputMask));
const native = sourceMask & tag;
const coerces =
accepts &&
!unknownSource &&
!(unionSource ? native : same);
const output = unionOutput(s2);
const traits = unionTraits(s2);
const sourceDeopt =
sourceBoundary && (!unionSource || coerces);
const effect =
output.type === neverTag
? 3
: traits & 4 || sourceDeopt
? 4
: coerces || traits & 8
? 2
: traits & 1 || tag & 9152
? 1
: 0;
out[i] = {
i,
s: s2,
m: accepts
? unknownSource
? inputMask
: unionSource
? native
? inputMask
: s2.type === undefinedTag && sourceMask & 32
? 32
: s2.type === nullTag && sourceMask & 16
? 16
: sourceMask & 2
? 2
: sourceMask
: sourceMask
: 0,
o: !!accepts && output.type !== neverTag,
e: effect,
f:
(traits & 7) |
(effect ? 1 : 0) |
(sourceDeopt ? 4 : 0) |
((!unknownSource && same) || tag & 37633 ? 16 : 0),
p:
(s2.type === objectTag &&
nestedLoc in s2.properties) ||
(broadObject && tag & 8320) ||
(broadNumber && tag & 2048)
? 0
: d !== U
? 1
: 2,
k:
tag & 8192
? s2.class
: s2.format === "env"
? s2.format
: s2.type,
n: unionNarrowSchema(s2),
r:
tag & 8256
? 8256
: tag & numberish
? numberish
: unionWiden(tag, nan2),
d,
};
}
return out;
};
var unionPlan = (members) => {
var _a;
const sequence = [];
const active = [];
const priority = [];
let total = 0;
let effects = 0;
for (let i = 0; i < members.length; i++) {
const member = members[i];
if (member.e > 1) effects |= member.m;
else if (!member.e) total |= member.m;
}
for (let i = 0; i < members.length; i++) {
const member = members[i];
if (
member.m === 0 ||
(member.e === 1 &&
!(member.f & 2) &&
!(member.m & (effects | ~total)))
)
continue;
const bucketed =
member.r !== -1 && (member.m & ~member.r) === 0;
const compatible =
member.e < 2 ||
(member.d !== U &&
(member.e === 4 || member.d[0] !== ""));
let bucket = bucketed
? member.p === 0
? priority[member.r] || active[member.r]
: active[member.r]
: U;
let open = U;
let broad = false;
if (bucket !== U)
for (let j = 0; j < bucket.t.length; j++) {
const group = bucket.t[j];
const first = group.a[0];
broad || (broad = group.p === 2);
if (
open === U &&
compatible &&
group.o &&
first.k === member.k &&
(first.e < 2 === member.e < 2 ||
(first.d !== U &&
first.d[0] === member.d?.[0])) &&
(group.p === 0) === (member.p === 0)
)
open = group;
else if (group.o && group.m & member.m)
group.o = false;
}
for (const key in active) {
const other = active[+key];
if (other !== bucket && other.m & member.m)
delete active[+key];
}
if (!bucketed) {
for (const key in priority)
if (priority[+key].m & member.m)
delete priority[+key];
sequence.push(unionGroup(member));
continue;
}
if (
bucket !== U &&
open === U &&
member.p === 1 &&
broad
) {
delete active[member.r];
bucket = U;
}
if (bucket === U) {
bucket = {
m: 0,
t: [],
};
active[member.r] = bucket;
priority[(_a = member.r)] || (priority[_a] = bucket);
sequence.push(bucket);
}
bucket.m |= member.m;
if (open !== U) {
open.a.push(member);
open.m |= member.m;
open.f &= -17;
} else {
const group = unionGroup(member);
group.o = compatible;
bucket.t.push(group);
}
if (!compatible) delete active[member.r];
}
const plan = [];
for (let i = 0; i < sequence.length; i++) {
const item = sequence[i];
if ("a" in item) plan.push(item);
else plan.push(...item.t.sort((a, b) => a.p - b.p));
}
const later = [];
let laterMask = 0;
let laterBroad = 0;
for (let i = plan.length - 1; i >= 0; i--) {
const group = plan[i];
let key = U;
let values;
for (let j = group.a.length - 1; j >= 0; j--) {
const member = group.a[j];
const d = member.d;
const conflict2 =
d === U ||
key === false ||
(key !== U && key !== d[0]);
if (key !== U && (conflict2 || values.has(d[1]))) {
member.f |= 8;
group.f |= 2;
}
if (conflict2) key = false;
else {
key = d[0];
(
values || (values = new Set())
).add(d[1]);
}
}
const head = group.a[0];
const route = head.r;
const semantic = later[route];
let overlaps =
!!(laterMask & group.m) &&
(!!(laterBroad & group.m) ||
key === false ||
semantic === U ||
semantic === false ||
semantic[0] !== key);
if (!overlaps && semantic !== U && semantic !== false) {
for (const value of values)
if (semantic[1].has(value)) {
overlaps = true;
break;
}
}
if (
overlaps ||
(laterMask &&
tagFlags[head.s.type] & 37633 &&
(head.s.to !== U || head.s.parser !== U))
)
group.f |= 10;
if (route !== -1 && (group.m & ~route) === 0) {
if (key === false) later[route] = false;
else if (semantic === U) later[route] = [key, values];
else if (semantic !== false) {
if (semantic[0] !== key) later[route] = false;
else
for (const value of values)
semantic[1].add(value);
}
} else laterBroad |= group.m;
if (laterMask & group.m) group.f |= 32;
laterMask |= group.m;
}
return plan;
};
var unionEmit = (
input,
self,
expectedSchema,
plan,
toPerCase,
trustedSelf,
) => {
const initialInline = input.i;
let output = B_refine(input);
const awaitAsync = plan.some((group) => group.f & 2);
const outputBySource = [];
let salvaged = "";
let rethrow = "";
let expected = "";
const ctx = {
f: (caught) =>
`${B_embed(input, unionFail.bind(U, expectedSchema, input.path))}(${input.v()}${salvaged}${caught})`,
r: () =>
rethrow || (rethrow = B_embed(input, getOrRethrow)),
s: () =>
expected ||
(expected = B_embed(input, expectedSchema)),
};
const unionDTrusted = (member) => {
const d = member.d;
const tag = tagFlags[member.s.type];
for (const group of plan)
for (const m of group.a) {
if (m === member) continue;
if (
m.d !== U
? m.d[0] === d[0] &&
unionLiteralEqual(m.d[1], d[1])
: m.m & tag
)
return false;
}
return true;
};
const compile2 = (member, source, target) => {
const mark = input.g.t;
const caseInput = B_scope(source);
caseInput.u = true;
caseInput.t = source.t;
caseInput.io = false;
caseInput.e = member.s;
if (source.s === target.e) caseInput.s = member.n;
const trustedD =
trustedSelf &&
member.p === 1 &&
!(member.f & 8) &&
member.d[0] !== "" &&
unionDTrusted(member)
? member.d
: U;
if (trustedD !== U) caseInput.s = member.s;
let caseOut;
const options = input.g.o;
input.g.o |= 4;
try {
caseOut = parse(caseInput);
} catch (exn) {
if (!self.perVariant) throw exn;
salvaged += `,${B_embed(input, getOrRethrow(exn))}`;
return U;
} finally {
input.g.o = options;
}
if (member.o) outputBySource[member.i] = caseOut.s;
const cond = {
c: "",
h: [],
};
let body = B_merge(caseOut, cond);
const async = caseOut.f & 1;
output.f |= async;
if (caseOut.t) {
output.t = true;
const itemVar = target.v();
if (async || caseOut.i !== itemVar) {
body += `${itemVar}=${async && awaitAsync ? "await " : ""}${caseOut.i}`;
if (itemVar === operationArgVar) input.g.r = true;
}
}
if (trustedD !== U) {
const dSchema = (member.s.properties ||
member.s.items)[trustedD[0]];
const dRead = inlinedProperty(
source.v(),
trustedD[0],
);
const dCond =
dSchema.type === nanTag
? `Number.isNaN(${dRead})`
: `${dRead}===${B_inlineConst(caseInput, dSchema)}`;
cond.c = cond.c ? `${dCond}&&${cond.c}` : dCond;
}
return {
c: cond.c,
b: body,
f:
(body !== "" && input.g.t !== mark ? 1 : 0) |
(async && awaitAsync ? 2 : 0) |
(member.f & 8),
};
};
const cases = [];
for (let i = 0; i < plan.length; i++) {
const group = plan[i];
if (group.a.length === 1 && group.f & 16) {
const c = compile2(group.a[0], input, input);
if (c !== U) {
c.f |= group.f & 8;
cases.push(c);
if (c.c === "" && c.b === "") break;
}
continue;
}
const mark = input.g.t;
const groupNarrow = group.a[0].n;
const narrowInput = B_scope(input);
narrowInput.io = false;
narrowInput.e = groupNarrow;
const narrow = parse(narrowInput);
if (tagFlags[groupNarrow.type] & 192) {
const resolved = unionRefDef(input.s);
const sourceVariant =
resolved !== U && resolved.anyOf !== U
? resolved.anyOf.find(
(v) => v.type === groupNarrow.type,
)
: U;
if (sourceVariant !== U) narrow.s = sourceVariant;
}
const inner = [];
for (let j = 0; j < group.a.length; j++) {
const c = compile2(group.a[j], narrow, narrowInput);
if (c !== U) {
inner.push(c);
if (c.c === "" && c.b === "") break;
}
}
if (!inner.length) continue;
const cond = {
c: "",
h: [],
};
let body;
let grouped = false;
if (inner.every((c) => c.b === "")) {
if (!inner.some((c) => c.c === "")) {
const fused = unionOr(inner);
body = B_merge(
B_refine(narrow, narrow.s, [
{
c: () => fused,
f: failInvalidType,
},
]),
cond,
);
} else body = B_merge(narrow, cond);
} else {
const narrowCode = B_merge(narrow, cond);
const only = inner.length === 1 ? inner[0] : U;
if (only !== U && narrowCode === "") {
if (only.c !== "")
cond.c = cond.c ? `${cond.c}&&${only.c}` : only.c;
body = only.b;
} else {
if (
inner.length > 1 &&
group.f & 32 &&
inner.every((c) => c.c)
) {
const fused = unionOr(inner);
cond.c = cond.c ? `${cond.c}&&${fused}` : fused;
}
body = narrowCode + unionEmitChain(inner, ctx);
grouped = inner.length > 1;
}
}
cases.push({
c: cond.c,
b: body,
f:
(body !== "" && input.g.t !== mark ? 1 : 0) |
(inner.some((c) => c.f & 2) ? 2 : 0) |
(group.f & 8) |
(grouped ? 4 : 0),
});
if (body === "" && cond.c === "") break;
}
const noop =
cases.every((c) => c.b === "") &&
cases.some((c) => c.c === "");
const pure =
!noop &&
cases.length > 0 &&
cases.every((c) => c.c !== "" && c.b === "");
const asyncDispatch = cases.some((c) => c.f & 2);
if (pure) {
const fused = unionOr(cases);
output = B_refine(
B_refine(
output,
output.s,
[
{
c: () => fused,
f: failInvalidType,
},
],
expectedSchema,
),
);
} else if (!noop) {
const dispatch2 = unionEmitChain(cases, ctx);
if (asyncDispatch) {
const itemVar = input.v();
output.i = `(async(${itemVar})=>{${dispatch2};return ${itemVar}})(${itemVar})`;
} else output.cp += dispatch2;
}
if (!asyncDispatch) output.i = input.i;
let out;
if (output.f & 1) {
output.i = `Promise.resolve(${output.i})`;
output.v = _notVar;
out = output;
} else if (
output.v === _var &&
input.cp === "" &&
output.cp === "" &&
!pure &&
initialInline === "i"
) {
input.hd = "";
input.v = _notVar;
input.i = initialInline;
out = input;
} else out = output;
const outputAnyOf = outputBySource.filter(Boolean);
out.s = outputAnyOf.length
? unionFactory(outputAnyOf)
: never_;
if (toPerCase !== U) {
out.io = true;
out.e = unionOutput(toPerCase);
return out;
}
out.e = self;
return B_markOutput(out, input);
};
var unionDecoder = (input) => {
const self = input.e;
const toPerCase =
self.parser === U &&
self.to !== U &&
self.to.noValidation !== true
? self.to
: U;
let variants = self.anyOf;
if (
(input.io && input.e === input.s) ||
(input.s === self &&
toPerCase === U &&
variants.every(unionIsNoop)) ||
(input.s.type === anyOfTag &&
toPerCase === U &&
input.s.anyOf.every((inS, idx) => {
const s2 = variants[idx];
return (
s2 !== U &&
!(tagFlags[inS.type] & 9152) &&
inS.type === s2.type &&
unionLiteralEqual(inS.const, s2.const) &&
inS.to === U &&
s2.to === U
);
}))
)
return input;
const initialTagFlag = tagFlags[input.s.type];
const trustedSelf = input.s === self || self.tr;
if (
initialTagFlag & 256 ||
(input.s.encoder === U && initialTagFlag & 512)
)
input.s = unknown;
if (variants.every(unionNeverLink))
B_invalidOperation(
input,
`Nothing decodes ${/* @__PURE__ */ inputExpression(self)}. Every member is S.never`,
);
const source = input.s;
variants = unionDropNullish(
unionDropNullish(variants, source, false),
toPerCase,
true,
);
let expected = self;
if (variants !== self.anyOf) {
expected = copySchema(self);
expected.anyOf = variants;
}
const nan2 = input.g.o & 2 ? 2048 : 0;
let flags = 0;
const sourceLiteral = isLiteral(source);
for (let i = 0; i < variants.length; i++) {
const member = variants[i];
if (
sourceLiteral &&
isLiteral(member) &&
unionLiteralEqual(member.const, source.const)
)
flags |= 1;
flags |=
tagFlags[member.type] & (64 | tagFlags[numberTag]);
}
const sourceTag = tagFlags[source.type];
if (!(sourceTag & 1) && !(flags & 1))
unionCheckPartial(input, source, self, variants, false);
if (toPerCase !== U) {
const perCase = unionTargetOwns(toPerCase)
? variants.map((v) =>
unionOutput(v).type === neverTag ? U : toPerCase,
)
: unionResolve(input, self, variants, toPerCase);
const attach =
self.refiner !== U || self.inputRefiner !== U
? unionRefinerAttacher(self)
: U;
variants = variants.map((variant, idx) => {
const to2 = perCase[idx];
return to2 === U && attach === U
? variant
: updateOutput(variant, (mut) => {
if (attach !== U) attach(mut);
if (to2 !== U) mut.to = to2;
});
});
}
return unionEmit(
input,
self,
expected,
unionPlan(
unionAnalyze(
unionMask(source, 2, nan2),
flags,
sourceTag,
variants,
source,
nan2,
),
),
toPerCase,
trustedSelf,
);
};
var unionRefinerAttacher = (self) => {
const cached = [];
return (mut) => {
for (let i = 0; i < 2; i++) {
const key = i ? "inputRefiner" : "refiner";
const source = self[key];
if (source !== U) {
const current = mut[key];
mut[key] = (input) => {
const shared =
cached[i] || (cached[i] = source(input));
return current === U
? shared
: current(input).concat(shared);
};
}
}
};
};
var unionRewrite = (input, variants, map) => {
const anyOf = [];
const has = {};
for (let idx = 0; idx < variants.length; idx++) {
const rewritten = map(variants[idx], idx);
anyOf.push(rewritten);
setHas(has, rewritten.type);
}
const mut = baseSchema(anyOfTag, false, unionDecoder);
mut.anyOf = anyOf;
mut.has = has;
mut.encoder = unionEncoder;
mut.perVariant = input.s.perVariant;
mut.tr = true;
return B_refine(input, unknown, U, mut);
};
var unionTargetOwns = (target) =>
target.noValidation === true ||
tagFlags[unionOutput(target).type] & 512 ||
(target.type === anyOfTag &&
target.anyOf.some((v) => tagFlags[v.type] & 512));
var unionEncoder = (input, target) => {
input.s;
if (unionTargetOwns(target)) return input;
const variants = unionDropNullish(
input.s.anyOf,
target,
true,
);
if (
target.perVariant &&
target.anyOf.length === variants.length
) {
const targets = target.anyOf;
return targets.every((tv, idx) => tv === variants[idx])
? input
: unionRewrite(
input,
variants,
(_variant, idx) => targets[idx],
);
}
const resolved = unionResolve(
input,
input.s,
variants,
target,
);
if (resolved.every((to2) => to2 === U)) return input;
return unionRewrite(input, variants, (variant, idx) => {
const to2 = resolved[idx];
return to2 === U
? variant
: updateOutput(variant, (mut) => {
mut.to = to2;
});
});
};
var unionOpposite = (schema) =>
schema.type === undefinedTag
? nullTag
: schema.type === nullTag
? undefinedTag
: U;
var unionResolve = (input, source, variants, target) => {
if (source.perVariant) return variants.map(() => target);
if (unionIsTransparent(target))
return unionResolveToUnion(
input,
source,
variants,
target,
);
if (!(tagFlags[target.type] & 1) && !target.noValidation)
unionCheckPartial(
input,
source,
target,
variants,
true,
);
return variants.map((variant) =>
unionOutput(variant).type === neverTag ? U : target,
);
};
var unionResolveToUnion = (
input,
source,
variants,
target,
) => {
const targets = target.anyOf;
const matches = [];
const covered = [];
let sourceNullish = 0;
for (let s2 = 0; s2 < variants.length; s2++) {
const sourceVariant = variants[s2];
const sourceOut = unionOutput(sourceVariant);
if (
!(
sourceVariant.type !== neverTag &&
sourceOut.type !== neverTag
)
)
continue;
if (
sourceOut === target ||
(target.anyOf !== U &&
sourceOut.anyOf === target.anyOf)
) {
for (let t = 0; t < targets.length; t++)
covered[t] = true;
continue;
}
const sameTyped = targets.filter(
(targetVariant, t) =>
targetVariant.type !== neverTag &&
!unionNeverLink(targetVariant) &&
unionSameType(sourceOut, targetVariant) &&
(covered[t] = true),
);
sourceNullish |= tagFlags[sourceOut.type] & 48;
if (sameTyped.length === 1) matches[s2] = sameTyped[0];
else if (sameTyped.length > 1)
matches[s2] =
tagFlags[sourceOut.type] & 9152 &&
sameTyped.includes(sourceOut)
? sourceOut
: unionFactory(sameTyped);
if (matches[s2] !== U) continue;
const opposite = unionOpposite(sourceOut);
if (opposite !== U)
matches[s2] = targets.find(
(candidate) =>
candidate.type === opposite &&
!unionNeverLink(candidate) &&
unionOutput(candidate).type !== neverTag,
);
if (matches[s2] === U)
unionInvalid(input, source, target, sourceOut, true);
}
for (let t = 0; t < targets.length; t++) {
const targetVariant = targets[t];
const opposite = unionOpposite(targetVariant);
if (
targetVariant.type !== neverTag &&
!unionNeverLink(targetVariant) &&
!covered[t] &&
(opposite === U ||
unionOutput(targetVariant).type === neverTag ||
!(sourceNullish & tagFlags[opposite]))
)
unionInvalid(
input,
source,
target,
targetVariant,
false,
);
}
return matches.map((matched, idx) => {
if (matched === U) return matched;
const sourceOut = unionOutput(variants[idx]);
return matched === sourceOut ||
(unionIsNoop(matched) &&
matched.refiner === U &&
matched.inputRefiner === U &&
matched.noValidation === U &&
(matched.const === U ||
unionLiteralEqual(
matched.const,
sourceOut.const,
)) &&
!(tagFlags[matched.type] & 9152) &&
unionSameType(matched, sourceOut))
? U
: matched;
});
};
var unionFactory = (schemas) => {
if (!schemas.length)
return panic("S.union requires at least one item");
if (schemas.length === 1) return schemas[0];
const has = {};
const anyOf = [];
for (let idx = 0; idx < schemas.length; idx++) {
const schema = schemas[idx];
const nested = unionIsTransparent(schema)
? schema.anyOf
: [schema];
for (let j = 0; j < nested.length; j++) {
const member = nested[j];
anyOf.push(member);
setHas(has, member.type);
}
}
const mut = baseSchema(anyOfTag, false, unionDecoder);
mut.anyOf = anyOf;
mut.encoder = unionEncoder;
mut.has = has;
return mut;
};
var internalRefine = (schema, makeRefiner) => {
return updateOutput(schema, (mut) => {
const refiner = makeRefiner(mut);
const existingRefiner = mut.refiner;
if (existingRefiner !== U)
mut.refiner = (input) => {
const arr = existingRefiner(input);
arr.push(...refiner(input));
return arr;
};
else mut.refiner = refiner;
});
};
var getMutErrorMessage = (mut) => {
const em = mut.errorMessage
? { ...mut.errorMessage }
: {};
mut.errorMessage = em;
return em;
};
var codecTo = (schema, target, decode, encode) => {
return updateOutput(schema, (mut) => {
const opened = typeof decode === "boolean";
const parser =
typeof decode === functionTag ? decode : U;
const serializer =
typeof encode === functionTag ? encode : U;
if (serializer !== U || opened) {
const targetMut = copySchema(target);
if (serializer !== U)
targetMut.serializer = serializer;
if (opened) targetMut.opens = decode;
mut.to = targetMut;
} else mut.to = target;
if (mut.content !== U && mut.opens === U)
mut.opens = true;
if (parser !== U) mut.parser = parser;
});
};
var nullAsUnit = copyTo(nullLiteral, unit);
var Option_getWithDefault = (schema, default_) => {
return updateOutput(schema, (mut) => {
const anyOf = mut.anyOf;
if (anyOf === U)
return panic(
`Can't set default for ${/* @__PURE__ */ inputExpression(mut)}`,
);
const outputItems = [];
const originalItems = [];
for (let idx = 0; idx < anyOf.length; idx++) {
const variant = anyOf[idx];
const outputSchema = getOutputSchema(variant);
if (outputSchema.type !== undefinedTag) {
if (!outputItems.includes(outputSchema))
outputItems.push(outputSchema);
originalItems.push(variant);
}
}
const item =
outputItems.length === 0
? panic(
`Can't set default for ${/* @__PURE__ */ inputExpression(mut)}`,
)
: outputItems.length === 1
? outputItems[0]
: unionFactory(outputItems);
if (default_.type === "value") {
const v = default_.value;
try {
getOp(0, 2, unknown, item)(v);
} catch (exn) {
const error = getOrRethrow(exn);
panic(
`Invalid default for ${/* @__PURE__ */ inputExpression(mut)}: ${error["message"]}`,
);
}
const originalItem =
originalItems.length === 1
? originalItems[0]
: unionFactory(originalItems);
try {
mut.default = getOp(
0,
1,
reverse(originalItem),
)(v);
} catch (_exn) {}
}
const decodeB = (input) => {
const target = input.e.to;
const output = B_next(
input,
default_.type === "value"
? B_inlineConst(
input,
Literal_parse(default_.value),
)
: `${B_embed(input, default_.callback)}()`,
target,
target,
);
if (default_.type === "value") output.v = _var;
return B_refine(output);
};
mut.anyOf = anyOf.map((variant) =>
getOutputSchema(variant).type === undefinedTag
? codecTo(variant, item, decodeB, B_neverSlot)
: variant,
);
});
};
var Option_getOr = (
schema,
defaultValue,
) =>
Option_getWithDefault(schema, {
type: "value",
value: defaultValue,
});
var Option_getOrWith = (
schema,
defaultCb,
) =>
Option_getWithDefault(schema, {
type: "callback",
callback: defaultCb,
});
var expects = (fnName, expected, got) =>
`S.${fnName} expects ${expected}, got ${got}`;
var assertNumericBound = (fnName, root, value) => {
const schema = getOutputSchema(root);
const tag = schema.type;
if (tag !== numberTag && tag !== bigintTag)
panic(
expects(
fnName,
"number | bigint schema",
inputExpression(schema),
),
);
if (
tag === bigintTag
? typeof value !== bigintTag
: typeof value !== numberTag || Number.isNaN(value)
)
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason: expects(
fnName,
inputExpression(schema),
stringify(value),
),
});
return schema;
};
var assertLengthBound = (fnName, root, value) => {
const schema = getOutputSchema(root);
if (schema.type !== stringTag && schema.type !== arrayTag)
panic(
expects(
fnName,
"string | array schema",
inputExpression(schema),
),
);
if (
typeof value !== numberTag ||
!Number.isSafeInteger(value) ||
value < 0
)
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason: expects(
fnName,
"integer >= 0",
stringify(value),
),
});
return schema;
};
var lit = (value) =>
typeof value === bigintTag ? `${value}n` : `${value}`;
var sizeKey = (schema, upper) =>
schema.type === arrayTag
? upper
? "maxItems"
: "minItems"
: schema.type === instanceTag
? upper
? "maxSize"
: "minSize"
: upper
? "maxLength"
: "minLength";
var sizeMember = (schema) => {
const tag = schema.type;
return tag === instanceTag
? ".size"
: tag === stringTag || tag === arrayTag
? ".length"
: U;
};
var withBounds = (schema, base) => {
const written = schema.bounds ?? 0;
const member = sizeMember(schema);
const sized = member !== U;
const minKey = sized ? sizeKey(schema, false) : "minimum";
const maxKey = sized ? sizeKey(schema, true) : "maximum";
const exMin = written & 4 ? schema.exclusiveMinimum : U;
const exMax = written & 8 ? schema.exclusiveMaximum : U;
const high =
exMax !== U ? exMax : written & 2 ? schema[maxKey] : U;
const low =
exMin !== U
? exMin
: written & 1 &&
!(sized && schema[minKey] === 0 && high !== 0)
? schema[minKey]
: U;
const mo = schema.multipleOf;
const subject0 = sized ? `${base}${member}` : base;
if (low === U && high === U)
return mo !== U ? `${subject0} % ${lit(mo)}` : base;
const subject =
mo !== U ? `(${subject0} % ${lit(mo)})` : subject0;
if (low === U)
return `${subject} ${exMax !== U ? "<" : "<="} ${lit(high)}`;
if (high === U)
return `${subject} ${exMin !== U ? ">" : ">="} ${lit(low)}`;
return exMin === U && exMax === U && low === high
? `${subject} == ${lit(low)}`
: `${lit(low)} ${exMin !== U ? "<" : "<="} ${subject} ${exMax !== U ? "<" : "<="} ${lit(high)}`;
};
var setBoundExpression = (mut, schema) => {
if (schema.bounds === U && schema.multipleOf === U) {
const base = schema.expression;
mut.expression = (s2) =>
withBounds(
s2,
base !== U
? base(s2)
: inputExpression(s2, true),
);
}
};
var exactDivisor = (d) =>
typeof d === bigintTag || Number.isInteger(d);
var multipleOfValidator = (d) => (value) => {
const ratio = value / d;
return (
Math.abs(ratio - Math.round(ratio)) <
Number.EPSILON * Math.max(Math.abs(ratio), 1)
);
};
var boundsRefiner = (input) => {
const s2 = input.e;
const written = s2.bounds ?? 0;
const checks = [];
const member = sizeMember(s2);
if (member !== U) {
const minKey = sizeKey(s2, false);
const maxKey = sizeKey(s2, true);
const min = written & 1 ? s2[minKey] : U;
const max = written & 2 ? s2[maxKey] : U;
const em = s2.errorMessage;
if (
min !== U &&
min === max &&
(em !== U ? em[minKey] : U) ===
(em !== U ? em[maxKey] : U)
)
checks.push({
c: (inputVar) => `${inputVar}${member}===${min}`,
f: B_failWithErrorMessage(minKey),
});
else {
if (min)
checks.push({
c: (inputVar) =>
`${inputVar}${member}>${min - 1}`,
f: B_failWithErrorMessage(minKey),
});
if (max !== U)
checks.push({
c: (inputVar) =>
`${inputVar}${member}<${max + 1}`,
f: B_failWithErrorMessage(maxKey),
});
}
} else {
const exMin = written & 4 ? s2.exclusiveMinimum : U;
const min =
exMin !== U ? exMin : written & 1 ? s2.minimum : U;
if (min !== U)
checks.push({
c: (inputVar) =>
`${inputVar}${exMin !== U ? ">" : ">="}${lit(min)}`,
f: B_failWithErrorMessage(
exMin !== U ? "exclusiveMinimum" : "minimum",
),
});
const exMax = written & 8 ? s2.exclusiveMaximum : U;
const max =
exMax !== U ? exMax : written & 2 ? s2.maximum : U;
if (max !== U)
checks.push({
c: (inputVar) =>
`${inputVar}${exMax !== U ? "<" : "<="}${lit(max)}`,
f: B_failWithErrorMessage(
exMax !== U ? "exclusiveMaximum" : "maximum",
),
});
const mo = s2.multipleOf;
if (mo !== U) {
let cond;
if (typeof mo === bigintTag)
cond = (inputVar) => `!(${inputVar}%${lit(mo)})`;
else if (exactDivisor(mo))
cond = (inputVar) => `${inputVar}%${lit(mo)}==0`;
else {
const embedded = B_embed(
input,
multipleOfValidator(mo),
);
cond = (inputVar) => `${embedded}(${inputVar})`;
}
checks.push({
c: cond,
f: B_failWithErrorMessage("multipleOf"),
});
}
}
return checks;
};
var updateBounds = (schema, update) =>
schema.bounds !== U || schema.multipleOf !== U
? updateOutput(schema, update)
: internalRefine(schema, (mut) => {
update(mut);
return boundsRefiner;
});
var carryMessage = (schema, key, maybeMessage) =>
maybeMessage === U || key === U
? schema
: updateOutput(schema, (mut) => {
getMutErrorMessage(mut)[key] = maybeMessage;
});
var setBoundMessage = (
mut,
schema,
key,
maybeMessage,
replaced,
) => {
const existing = schema.errorMessage;
if (maybeMessage !== U)
getMutErrorMessage(mut)[key] = maybeMessage;
else if (existing !== U && existing[key] !== U)
getMutErrorMessage(mut)[key] = U;
if (
replaced !== U &&
existing !== U &&
existing[replaced] !== U
)
getMutErrorMessage(mut)[replaced] = U;
};
var narrowsLower = (schema, value, exclusive) => {
const bound = value;
const inclusive = schema.minimum;
const strict2 = schema.exclusiveMinimum;
return (
(inclusive === U ||
(exclusive
? bound >= inclusive
: bound > inclusive)) &&
(strict2 === U || bound > strict2)
);
};
var narrowsUpper = (schema, value, exclusive) => {
const bound = value;
const inclusive = schema.maximum;
const strict2 = schema.exclusiveMaximum;
return (
(inclusive === U ||
(exclusive
? bound <= inclusive
: bound < inclusive)) &&
(strict2 === U || bound < strict2)
);
};
var narrowsSize = (current, value, upper) =>
upper
? current === U || value < current
: value > (current ?? 0);
var conflict = (incoming, existing) => {
panic(
`${/* @__PURE__ */ inputExpression(incoming)} contradicts ${/* @__PURE__ */ inputExpression(existing)}`,
);
};
var asBound = (schema, key, bit, value) => {
const mut = {
...schema,
bounds: bit,
};
mut[key] = value;
setBoundExpression(mut, schema);
return mut;
};
var assertLower = (schema, value, exclusive) => {
const key = exclusive ? "exclusiveMinimum" : "minimum";
const bit = exclusive ? 4 : 1;
const bound = value;
const inclusive = schema.maximum;
const strict2 = schema.exclusiveMaximum;
if (
inclusive !== U &&
(exclusive ? bound >= inclusive : bound > inclusive)
)
conflict(
asBound(schema, key, bit, value),
asBound(schema, "maximum", 2, inclusive),
);
if (strict2 !== U && bound >= strict2)
conflict(
asBound(schema, key, bit, value),
asBound(schema, "exclusiveMaximum", 8, strict2),
);
};
var assertUpper = (schema, value, exclusive) => {
const key = exclusive ? "exclusiveMaximum" : "maximum";
const bit = exclusive ? 8 : 2;
const bound = value;
const inclusive = schema.minimum;
const strict2 = schema.exclusiveMinimum;
if (
inclusive !== U &&
(exclusive ? bound <= inclusive : bound < inclusive)
)
conflict(
asBound(schema, key, bit, value),
asBound(schema, "minimum", 1, inclusive),
);
if (strict2 !== U && bound <= strict2)
conflict(
asBound(schema, key, bit, value),
asBound(schema, "exclusiveMinimum", 4, strict2),
);
};
var assertSize = (schema, value, upper) => {
const otherKey = sizeKey(schema, !upper);
const other = schema[otherKey];
if (
other !== U &&
(upper ? value < other : value > other)
)
conflict(
asBound(
schema,
sizeKey(schema, upper),
upper ? 2 : 1,
value,
),
asBound(schema, otherKey, upper ? 1 : 2, other),
);
};
var gte = (
root,
minValue,
maybeMessage,
) => {
const schema = assertNumericBound("gte", root, minValue);
assertLower(schema, minValue, false);
if (!narrowsLower(schema, minValue, false)) {
const written = schema.bounds ?? 0;
return carryMessage(
root,
written & 4
? "exclusiveMinimum"
: written & 1
? "minimum"
: U,
maybeMessage,
);
}
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = ((schema.bounds ?? 0) & -5) | 1;
mut.minimum = minValue;
mut.exclusiveMinimum = U;
setBoundMessage(
mut,
schema,
"minimum",
maybeMessage,
"exclusiveMinimum",
);
});
};
var lte = (
root,
maxValue,
maybeMessage,
) => {
const schema = assertNumericBound("lte", root, maxValue);
assertUpper(schema, maxValue, false);
if (!narrowsUpper(schema, maxValue, false)) {
const written = schema.bounds ?? 0;
return carryMessage(
root,
written & 8
? "exclusiveMaximum"
: written & 2
? "maximum"
: U,
maybeMessage,
);
}
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = ((schema.bounds ?? 0) & -9) | 2;
mut.maximum = maxValue;
mut.exclusiveMaximum = U;
setBoundMessage(
mut,
schema,
"maximum",
maybeMessage,
"exclusiveMaximum",
);
});
};
var minLength = (
root,
length2,
maybeMessage,
) => {
const schema = assertLengthBound(
"minLength",
root,
length2,
);
assertSize(schema, length2, false);
const key = sizeKey(schema, false);
if (
!narrowsSize(schema[key], length2, false) &&
!(length2 === 0 && schema[key] === U)
)
return carryMessage(
root,
(schema.bounds ?? 0) & 1 ? key : U,
maybeMessage,
);
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = (schema.bounds ?? 0) | 1;
mut[key] = length2;
setBoundMessage(mut, schema, key, maybeMessage);
});
};
var maxLength = (
root,
length2,
maybeMessage,
) => {
const schema = assertLengthBound(
"maxLength",
root,
length2,
);
assertSize(schema, length2, true);
const key = sizeKey(schema, true);
if (!narrowsSize(schema[key], length2, true))
return carryMessage(
root,
(schema.bounds ?? 0) & 2 ? key : U,
maybeMessage,
);
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = (schema.bounds ?? 0) | 2;
mut[key] = length2;
setBoundMessage(mut, schema, key, maybeMessage);
});
};
var nonEmpty = (
schema,
maybeMessage,
) => minLength(schema, 1, maybeMessage);
var stringFormat = (
format,
test,
flag,
expression,
) =>
initSchema(
stringTag,
stringDecoderFn,
(s2) => {
const re =
typeof test === "string"
? new RegExp(test, "i")
: test;
s2.format = format;
if (expression) s2.expression = () => expression;
if (flag) s2.formatFlag = flag;
s2.refiner = (input) => {
return [
{
c: (inputVar) =>
`${B_embed(input, re)}${re instanceof RegExp ? ".test" : ""}(${inputVar})`,
f: B_failWithErrorMessage("format"),
},
];
};
},
);
var ipv4Pattern =
"(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
var ipv6Pattern = () =>
"(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|" +
ipv4Pattern +
")|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)";
var uriPattern = (
schemeOptional,
scheme,
) =>
"^(?:" +
(scheme || "[a-z][a-z0-9+\\-.]*") +
":)" +
schemeOptional +
"(?:\\/\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:" +
ipv6Pattern() +
"|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|" +
ipv4Pattern +
"|(?:[a-z0-9\\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\\?(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$";
var uri = stringFormat(
"uri",
uriPattern(""),
1,
);
var invalidDateRefine = (input) => {
return B_refine(input, input.e, [
{
c: (inputVar) =>
`!Number.isNaN(${inputVar}.getTime())`,
f: failInvalidType,
},
]);
};
var dateTimeString = initSchema(
stringTag,
stringDecoderFn,
(s2) => {
s2.format = "date-time";
s2.formatFlag = 1;
},
);
var date = initSchema(
instanceTag,
(input) => {
const inputTagFlag = tagFlags[input.s.type];
if (inputTagFlag & 2)
return invalidDateRefine(
B_next(input, `new Date(${input.i})`, date),
);
else if (inputTagFlag & 1)
return invalidDateRefine(instanceDecoder(input));
else if (
inputTagFlag & 8192 &&
input.s.class === date.class
)
return input;
else
return B_unsupportedDecode(input, input.s, input.e);
},
(s2) => {
s2.class = Date;
s2.encoder = (input, target) => {
if (tagFlags[target.type] & 2) {
if (input.s.noValidation)
return parse(
B_refine(
B_next(
input,
`${input.i}.toISOString()`,
dateTimeString,
target,
),
),
);
const output = B_nextVar(
input,
dateTimeString,
target,
);
output.cp = `let ${output.i};try{${output.i}=${input.v()}.toISOString()}catch(_){${B_embedInvalidInput(input, input.s)}}`;
return parse(B_refine(output));
} else return input;
};
},
);
var panicArity = () =>
panic(
"Expected at most 3 schemas and a value. Use .with(S.to, ...) for a longer chain",
);
var dispatch = (n, a, b, c, d, tail, rev, flag) => {
if (n > 4) panicArity();
let data = U;
let immediate = !isOwnSchema(a);
if (immediate) {
((data = a), (a = b), (b = c), (c = d), n--);
if (n < 1 || !isOwnSchema(a)) panicNotSchema();
}
const k =
n > 1 && isOwnSchema(b)
? n > 2 && isOwnSchema(c)
? 3
: 2
: 1;
if (n > k) {
if (immediate || n > k + 1)
panic(
"Expected a Sury schema. The data goes first or last",
);
data =
k > 2
? isOwnSchema(d)
? panicArity()
: d
: k > 1
? c
: b;
immediate = true;
}
const first = rev ? reverse(a) : a;
const op =
k > 2
? getOp(
flag,
tail ? 4 : 3,
first,
b,
c,
tail,
)
: k > 1
? getOp(
flag,
tail ? 3 : 2,
first,
b,
tail,
)
: getOp(
flag,
tail ? 2 : 1,
first,
tail,
);
return immediate ? op(data) : op;
};
function parseOrThrow(a, b, c, d) {
return dispatch(
arguments.length,
a,
b,
c,
d,
U,
false,
8,
);
}
var getStandardJSONSchema = (
schema,
options,
isOutput2,
) => {
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason:
"~standard.jsonSchema requires S.enableStandardJSONSchema() to be called first",
});
};
Object.defineProperty(schemaPrototype, "toString", {
value: function () {
const input = inputExpression(this);
const output = inputExpression(
reverse(this),
);
return `Schema<${input === output ? input : `${input}, ${output}`}>`;
},
});
Object.defineProperty(schemaPrototype, "~standard", {
get: function () {
const schema = this;
let opFlag = U;
let validateOp;
const standard = {
version: 1,
vendor,
validate: (input) => {
if (opFlag !== globalConfig.f) {
validateOp = getOp(
1537,
2,
unknown,
schema,
);
opFlag = globalConfig.f;
}
return validateOp(input);
},
jsonSchema: {
input: (options) =>
getStandardJSONSchema(schema, options, false),
output: (options) =>
getStandardJSONSchema(schema, options, true),
},
};
valueOptions[valKey] = standard;
Object.defineProperty(
schema,
"~standard",
valueOptions,
);
return standard;
},
});
var union = (values) =>
unionFactory(values.map(definitionToSchema));
var nullable2 = (
definition,
maybeOr,
) => {
const schema =
definitionToSchema(definition);
if (maybeOr !== U) {
const schema2 = unionFactory([schema, nullAsUnit]);
if (typeof maybeOr === functionTag)
return Option_getOrWith(
schema2,
maybeOr,
);
else
return Option_getOr(schema2, maybeOr);
} else return unionFactory([schema, nullLiteral]);
};
const imageSchema = definitionToSchema({
id: float,
created: date,
title: string.with(nonEmpty).with(maxLength, 100),
type: union(["jpg", "png"]),
size: float,
url: uri,
});
const ratingSchema = definitionToSchema({
id: float,
stars: float.with(gte, 1).with(lte, 5),
title: string.with(nonEmpty).with(maxLength, 100),
text: string.with(nonEmpty).with(maxLength, 1e3),
images: array(imageSchema),
});
parseOrThrow(
definitionToSchema({
id: float,
created: date,
title: string.with(nonEmpty).with(maxLength, 100),
brand: string.with(nonEmpty).with(maxLength, 30),
description: string.with(nonEmpty).with(maxLength, 500),
price: float.with(gte, 1).with(lte, 1e4),
discount: float
.with(gte, 1)
.with(lte, 100)
.with(nullable2),
quantity: float.with(gte, 0).with(lte, 10),
tags: array(
string.with(nonEmpty).with(maxLength, 30),
),
images: array(imageSchema),
ratings: array(ratingSchema),
}),
)({});
var pathEmpty = [];
var pathDynamic = ["[]"];
var inlineUnsafeRe = /["\\\n\r]/;
var inlinedValueFromString = (str) =>
inlineUnsafeRe.test(str) ? JSON.stringify(str) : `"${str}"`;
var jsIdentRe = /^[A-Za-z_$][\w$]*$/;
var inlinedObjectKey = (key) =>
key === "__proto__"
? '["__proto__"]'
: jsIdentRe.test(key)
? key
: inlinedValueFromString(key);
var inlinedProperty = (obj, key, numeric) =>
numeric && /^\d+$/.test(key)
? `${obj}[${key}]`
: key === "__proto__" || !jsIdentRe.test(key)
? `${obj}[${inlinedValueFromString(key)}]`
: `${obj}.${key}`;
var pathConcat = (path, concatedPath) =>
path.length
? concatedPath.length
? path.concat(concatedPath)
: path
: concatedPath;
var pathToText = (path) => {
let text = "";
for (let idx = 0; idx < path.length; idx++) {
const segment = path[idx];
text +=
typeof segment !== "string"
? `[${String(segment)}]`
: /^\d+$/.test(segment)
? `[${segment}]`
: segment === "[]"
? segment
: jsIdentRe.test(segment)
? text
? `.${segment}`
: segment
: `[${inlinedValueFromString(segment)}]`;
}
return text;
};
var stringTag = "string";
var numberTag = "number";
var bigintTag = "bigint";
var booleanTag = "boolean";
var symbolTag = "symbol";
var nullTag = "null";
var undefinedTag = "undefined";
var nanTag = "nan";
var functionTag = "function";
var instanceTag = "instance";
var arrayTag = "array";
var objectTag = "object";
var anyOfTag = "anyOf";
var neverTag = "never";
var unknownTag = "unknown";
var refTag = "ref";
var tagFlags = {
[unknownTag]: 1,
[stringTag]: 2,
[numberTag]: 4,
[booleanTag]: 8,
[undefinedTag]: 16,
[nullTag]: 32,
[objectTag]: 64,
[arrayTag]: 128,
[anyOfTag]: 256,
[refTag]: 512,
[bigintTag]: 1024,
[nanTag]: 2048,
[functionTag]: 4096,
[instanceTag]: 8192,
[neverTag]: 32768,
[symbolTag]: 16384,
};
var vendor = "sury";
var s = Symbol(vendor);
vendor + "";
var U = void 0;
var immutableEmptyArray = [];
var immutableEmptyObject = Object.create(null);
var isSchemaObject = (obj) =>
typeof obj === objectTag && obj !== null && "~standard" in obj;
var isLiteral = (schema) => "const" in schema;
var isOptional = (schema) =>
schema.type === undefinedTag ||
(schema.type === anyOfTag && undefinedTag in schema.has);
var namedConstructor = (unknown2) => {
const ctor = Object.getPrototypeOf(unknown2)?.constructor;
return ctor !== Object && ctor?.name;
};
var stringifyLeaf = (unknown2) => {
const tagFlag = tagFlags[typeof unknown2];
if (tagFlag & 16) return undefinedTag;
else if (tagFlag & 4160)
return unknown2 === null
? nullTag
: Array.isArray(unknown2)
? `Array(${unknown2.length})`
: namedConstructor(unknown2) || objectTag;
else if (tagFlag & 2) return `"${unknown2}"`;
else if (tagFlag & 1024) return `${unknown2}n`;
else return unknown2.toString();
};
var stringify = (unknown2) => {
if (unknown2 !== null && typeof unknown2 === objectTag) {
if (Array.isArray(unknown2)) {
const items = unknown2;
let body = "";
for (let idx = 0; idx < items.length; idx++) {
if (idx === 5) {
body += ", ...";
break;
}
body += (idx ? ", " : "") + stringifyLeaf(items[idx]);
}
return `[${body}]`;
}
if (!namedConstructor(unknown2)) {
const dict2 = unknown2;
let body = "";
let count = 0;
for (const key in dict2) {
if (count++ === 5) {
body += "... ";
break;
}
body += key + ": " + stringifyLeaf(dict2[key]) + "; ";
}
return body ? `{ ${body}}` : "{}";
}
}
return stringifyLeaf(unknown2);
};
var inputExpression = (schema, skipOverride) => {
if (schema.name) return schema.name;
else if (schema.const !== U) return stringify(schema.const);
else if (schema.expression && !skipOverride) return schema.expression(schema);
else if (schema.anyOf !== U) {
const anyOf = schema.anyOf;
const seen = new Set();
let body = "";
for (let idx = 0; idx < anyOf.length; idx++) {
const expression = inputExpression(anyOf[idx]);
if (!seen.has(expression)) {
seen.add(expression);
body += (body ? " | " : "") + expression;
}
}
return body;
} else if (schema.type === objectTag) {
const properties = schema.properties;
const additionalItems = schema.additionalItems;
let body = "";
for (const location in properties)
body +=
location +
": " +
inputExpression(properties[location]) +
"; ";
if (typeof additionalItems === objectTag)
body +=
"[key: string]: " +
inputExpression(additionalItems) +
"; ";
return body ? `{ ${body}}` : "{}";
} else if (schema.type === arrayTag) {
const additionalItems = schema.additionalItems;
if (typeof additionalItems === objectTag) {
const item = additionalItems;
const itemName = inputExpression(item);
return (
(item.type === anyOfTag || item.bounds !== U || item.multipleOf !== U
? `(${itemName})`
: itemName) + "[]"
);
}
const items = schema.items;
let body = "";
for (let idx = 0; idx < items.length; idx++)
body += (idx ? ", " : "") + inputExpression(items[idx]);
return `[${body}]`;
} else if (schema.format) return schema.format;
else if (schema.type === instanceTag) return schema.class.name;
else return schema.type;
};
var Schema = function () {};
var schemaPrototype = Object.create(null);
Object.defineProperty(schemaPrototype, "with", {
value(fn, ...args) {
return fn(this, ...args);
},
});
Schema.prototype = schemaPrototype;
var reversedKey = "r";
var SelfReverseSchema = function () {};
var selfReversePrototype = Object.create(schemaPrototype);
Object.defineProperty(selfReversePrototype, reversedKey, {
get() {
return this;
},
});
Object.defineProperty(selfReversePrototype, "sr", { value: true });
SelfReverseSchema.prototype = selfReversePrototype;
var isOwnSchema = (value) => {
const proto =
typeof value === objectTag && value && Object.getPrototypeOf(value);
return proto === schemaPrototype || proto === selfReversePrototype;
};
var panicNotSchema = () => panic("Expected a Sury schema");
var seq = 1;
var exnId = {};
var SuryError = class extends Error {
constructor(params) {
super();
Object.assign(this, params);
}
get message() {
return formatErrorMessage(this);
}
get _1() {
return this;
}
get RE_EXN_ID() {
return exnId;
}
};
Object.defineProperty(SuryError.prototype, "name", { value: "SuryError" });
Object.defineProperty(SuryError.prototype, "s", { value: s });
var getOrRethrow = (exn) => {
if (exn && exn.s === s) return exn;
throw exn;
};
var panic = (message) => {
throw new Error(`[Sury] ${message}`);
};
var formatErrorMessage = (error) =>
`${error.path.length ? `Failed at ${/* @__PURE__ */ pathToText(error.path)}: ` : ""}${error.reason}`;
var globalConfig = {
m: formatErrorMessage,
d: U,
a: "strip",
f: 0,
};
var valueOptions = {};
var configurableValueOptions = { configurable: true };
var valKey = "value";
var baseSchema = (tag, selfReverse, decoder) => {
const schema = new (selfReverse ? SelfReverseSchema : Schema)();
schema.type = tag;
schema.seq = seq++;
schema.decoder = decoder;
return schema;
};
var noopDecoder = (input) => input;
var initSchema = (tag, decoder, init) => {
const schema = baseSchema(tag, true, decoder);
return (init?.(schema), schema);
};
var unknown = baseSchema(unknownTag, true, noopDecoder);
var copySchema = (schema) => {
const c = Object.assign(new Schema(), schema);
c.seq = seq++;
if (schema.content !== U) setContent(c, schema.content);
if (schema.bc !== U) setBytesCodec(c, schema.bc);
return c;
};
var copyTo = (from, to2) => {
const mut = copySchema(from);
mut.to = to2;
return mut;
};
var setContent = (schema, content) => {
valueOptions[valKey] = content;
Object.defineProperty(schema, "content", valueOptions);
};
var setBytesCodec = (schema, codec) => {
valueOptions[valKey] = codec;
Object.defineProperty(schema, "bc", valueOptions);
};
var updateOutput = (schema, fn) => {
const root = copySchema(schema);
let mut = root;
while (mut.to) {
const next = copySchema(mut.to);
mut.to = next;
mut = next;
}
fn(mut);
return root;
};
var setHas = (has, tag) => {
has[tagFlags[tag] & 768 ? unknownTag : tag] = true;
};
function _var() {
return this.i;
}
var _linkVar = function () {
return (this.b || this.prev).v();
};
function _notVarBeforeValidation() {
const val = this;
const v = B_varWithoutAllocation(val.g);
val.cp = `let ${v}=${val.i};`;
val.i = v;
val.v = _var;
return v;
}
function _notVarAtParent() {
const val = this;
const parent = val.p;
if (parent.fz) {
val.v = _var;
return val.i;
}
const v = B_varWithoutAllocation(val.g);
B_hoistDecl(parent, `${v}=${val.i}`);
val.v = _var;
val.i = v;
return v;
}
function _notVar() {
const val = this;
if (val.fz) {
val.v = _var;
val.i = `(${val.i})`;
return val.i;
}
const v = B_varWithoutAllocation(val.g);
if (val.prev !== U) {
if (val.i === "") val.cp = `let ${v};` + val.cp;
else val.cp += `let ${v}=${val.i};`;
} else B_hoistDecl(val, val.i === "" ? v : `${v}=${val.i}`);
val.v = _var;
val.i = v;
return v;
}
var operationArgVar = "i";
var failInvalidType = (input) => {
const em = input.e.errorMessage;
return B_invalidInputBuilder(
U,
U,
em &&
(input.e.format !== U && em.format !== U
? em.format
: em.type !== U
? em.type
: em._),
)(input);
};
var B_embed = (b, value) => (b.g.t++, B_embedPure(b, value));
var B_embedPure = (b, value) => `e[${b.g.e.push(value) - 1}]`;
var B_inlineConst = (b, schema) => {
const tagFlag = tagFlags[schema.type],
const_ = schema.const;
return tagFlag & 16
? "void 0"
: tagFlag & 2
? inlinedValueFromString(const_)
: tagFlag & 1024
? const_ + "n"
: tagFlag & 28672
? B_embedPure(b, schema.const)
: const_;
};
var B_varWithoutAllocation = (g) => `v${++g.v}`;
var B_hoistDecl = (owner, decl) => {
owner.hd += (owner.hd && ",") + decl;
};
var B_operationArg = (schema, expected, flag, defs) => {
return {
b: U,
p: U,
v: _var,
i: operationArgVar,
s: schema,
io: U,
e: expected,
prev: U,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathEmpty,
g: {
d: defs,
o: flag,
e: [],
v: -1,
t: 0,
},
o: U,
};
};
var B_throw = (errorDetails) => {
throw new SuryError(errorDetails);
};
var B_unsupportedDecode = (b, from, target) =>
B_throw({
code: "unsupported_decode",
from,
to: target,
reason: `Can't decode ${/* @__PURE__ */ inputExpression(from)} -> ${/* @__PURE__ */ inputExpression(target)}. Define custom codec with S.to`,
path: b.path,
});
var B_failWithArg = (b, fn, arg) =>
`${B_embed(b, (a) => {
B_throw(fn(a));
})}(${arg})`;
var B_markThrow = (b) => {
b.g.t++;
};
var B_foreignDetails = (input, to2, cause) => ({
code: "invalid_conversion",
from: input.s,
to: to2,
cause,
path: input.path,
reason:
cause instanceof Error
? ("" + cause).replace(/^Error: /, "")
: stringify(cause),
});
var B_errorOf = (input) => {
let to2 = input.e;
while (to2.to) to2 = to2.to;
return (e) =>
e && e.s === s ? e : new SuryError(B_foreignDetails(input, to2, e));
};
var B_makeInvalidInputDetails = (
expected,
received,
path,
input,
unionErrors,
reasonOverride,
) => {
let reasonRef = reasonOverride;
if (reasonRef === U) {
const expectedExpression = inputExpression(expected);
const receivedExpression = stringify(input);
reasonRef = `Expected ${expectedExpression}, received ${expectedExpression === receivedExpression ? "invalid " : ""}${receivedExpression}`;
}
if (unionErrors) {
const seenReasons = new Set();
for (let idx = 0; idx < unionErrors.length; idx++) {
const caseError = unionErrors[idx];
const line = `
- ${caseError.path.length ? `At ${/* @__PURE__ */ pathToText(caseError.path)}: ` : ""}${caseError.reason.split("\n").join("\n ")}`;
if (!seenReasons.has(line)) {
seenReasons.add(line);
reasonRef += line;
}
}
}
return {
code: "invalid_input",
expected,
received,
path,
reason: reasonRef,
unionErrors,
input,
};
};
var B_invalidInputBuilder =
(expected, extraPath = pathEmpty, reasonOverride) =>
(input) => {
const path = pathConcat(input.path, extraPath);
return (value) =>
B_makeInvalidInputDetails(
expected ?? input.e,
(input.prev || input).s,
path,
value,
U,
reasonOverride,
);
};
var B_failWithErrorMessage = (key, defaultMessage) => (input) => {
const em = input.e.errorMessage;
const m = em?.[key] ?? em?.["_"] ?? defaultMessage;
return m !== U
? B_invalidInputBuilder(U, U, m)(input)
: failInvalidType(input);
};
var B_embedInvalidInput = (input, expected = input.e) =>
B_failWithArg(input, B_invalidInputBuilder(expected)(input), input.v());
var B_emitChecks = (val, inputVar) => {
const checks = val.vc;
let out = "",
i = 0,
len = checks.length;
while (i < len) {
const head = checks[i],
fail = head.f;
let cond = head.c(inputVar);
i++;
while (i < len && checks[i].f === fail) {
cond += "&&" + checks[i].c(inputVar);
i++;
}
out += `${cond}||${B_failWithArg(val, fail(val), inputVar)};`;
}
return out;
};
var B_merge = (val, out) => {
let current = val,
code = "";
while (current !== U) {
const val2 = current;
current = val2.prev;
let currentCode = "";
if (val2.vc) {
if (out && (!val2.t || (!val2.prev.t && val2.cp === ""))) {
const inputVar = (current || val2).v();
const checks = val2.vc;
let hoisted = "";
for (let i = 0; i < checks.length; i++) {
const check = checks[i];
const condCode = check.c(inputVar);
if (check.f === failInvalidType)
hoisted = hoisted ? `${hoisted}&&${condCode}` : condCode;
else if (val2.e.noValidation !== true)
currentCode += `${condCode}||${B_failWithArg(val2, check.f(val2), inputVar)};`;
}
if (hoisted) {
out.c = out.c ? `${hoisted}&&${out.c}` : hoisted;
out.h.unshift({
v: val2,
i: inputVar,
c: hoisted,
});
}
} else if (val2.e.noValidation !== true)
currentCode = B_emitChecks(val2, (current || val2).v());
}
if (val2.hd) currentCode += `let ${val2.hd};`;
val2.fz = true;
code = val2.cp + currentCode + code;
}
return code;
};
var B_linkVar = (val, nextVal) => {
const get = val.v.bind(val);
val.v = () => ((nextVal.i = get()), (nextVal.v = _var), nextVal.i);
};
var B_next = (prev, initial, schema, expected = prev.e) => {
return {
b: U,
p: U,
v: _notVar,
i: initial,
s: schema,
io: U,
e: expected,
prev,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: true,
path: prev.path,
g: prev.g,
o: U,
};
};
var B_refine = (val, schema = val.s, checks, expected = val.e) => {
const shouldLink = val.v !== _var;
const nextVal = {
b: U,
p: U,
v: shouldLink ? _linkVar : _var,
i: val.i,
s: schema,
io: U,
e: expected,
prev: val,
f: val.f,
d: val.d,
fv: U,
cp: "",
hd: "",
fz: U,
vc: checks,
u: U,
t: val.t,
path: val.path,
g: val.g,
o: U,
};
if (shouldLink) B_linkVar(val, nextVal);
return nextVal;
};
var B_pushCheck = (val, check) => {
(val.vc ?? (val.vc = [])).push(check);
};
var B_markOutput = (val, valInput) => {
let outC;
const ir = valInput.e.inputRefiner;
if (ir) {
const c = ir(valInput);
if (c.length) (valInput.vc ?? (valInput.vc = [])).push(...c);
}
const rf = val.e.refiner;
if (rf) {
const c = rf(val);
if (c.length) outC = c;
}
if (outC && val.f & 1) {
const v = val.v();
val.i = `${v}.then(${v}=>{${B_merge(B_refine(B_scope(val), U, outC))}return ${v}})`;
val.v = _notVar;
} else if (outC) val = B_refine(val, U, outC);
val.io = true;
return val;
};
var B_hoistChildChecks = (parent, child, key) => {
const checks = child.vc;
if (checks) {
const accessor = inlinedProperty("", key, parent.s.type === arrayTag);
for (let i = 0; i < checks.length; i++) {
const check = checks[i];
B_pushCheck(parent, {
c: (v) => check.c(v + accessor),
f: check.f,
});
}
child.vc = U;
}
};
var B_dynamicScope = (from, locationVar) => {
const schemaAdditionalItems = from.s.additionalItems;
const expectedAdditionalItems = from.e.additionalItems;
return {
b: U,
p: from,
v: _notVarBeforeValidation,
i: `${from.v()}[${locationVar}]`,
s:
schemaAdditionalItems !== U && typeof schemaAdditionalItems !== "string"
? schemaAdditionalItems
: unknown,
io: U,
e:
expectedAdditionalItems !== U &&
typeof expectedAdditionalItems !== "string"
? expectedAdditionalItems
: unknown,
prev: U,
f: from.f,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathEmpty,
g: from.g,
o: U,
};
};
var B_nextConst = (from, schema, expected) =>
B_next(from, B_inlineConst(from, schema), schema, expected);
var B_nextVar = (input, schema = input.e, expected = schema) => {
const output = B_next(
input,
B_varWithoutAllocation(input.g),
schema,
expected,
);
output.v = _var;
return output;
};
var B_nextVarOutput = (input, initial, schema, expected = schema) => {
const output = B_next(input, initial, schema, expected);
output.v = _var;
output.io = true;
return output;
};
var B_asyncVal = (from, initial) => {
const v = B_next(from, initial, from.s);
v.f = 1;
return v;
};
var B_addObjectField = (objectVal, location, val) => {
if (objectVal.s.type === arrayTag) objectVal.s.items.push(val.s);
else {
if (!val.o) objectVal.s.required.push(location);
objectVal.s.properties[location] = val.s;
}
if (val.f & 1) val.v();
objectVal.cp += B_merge(val);
objectVal.d[location] = val;
};
var B_addKey = (objVal, key, value) => `${objVal.v()}[${key}]=${value.i}`;
var B_scope = (val) => {
const shouldLink = val.v !== _var;
const nextVal = {
b: val,
p: U,
v: shouldLink ? _linkVar : _var,
i: val.i,
s: val.s,
io: val.io,
e: val.e,
prev: U,
f: 0,
d: val.d,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: false,
t: false,
path: val.path,
g: val.g,
o: U,
};
if (shouldLink) B_linkVar(val, nextVal);
return nextVal;
};
var B_neverSlot = (input) =>
B_invalidOperation(
input,
`Nothing decodes ${/* @__PURE__ */ inputExpression(input.e)} -> ${/* @__PURE__ */ inputExpression(input.e.to)}. It is marked with S.never`,
);
var B_invalidOperation = (val, description) =>
B_throw({
code: "invalid_operation",
reason: description,
path: val.path,
});
var B_mergeWithCatch = (val, catchFn, appendSafe, pureSince) => {
const valCode = B_merge(val);
const pure = pureSince !== U && val.g.t === pureSince;
if ((valCode === "" || pure) && !(val.f & 1))
return appendSafe ? valCode + appendSafe() : pure ? "" : valCode;
const errorVar = B_varWithoutAllocation(val.g);
B_markThrow(val);
const catchCode = `${catchFn(errorVar)};throw ${errorVar}`;
if (val.f & 1) val.i = `${val.i}.catch(${errorVar}=>{${catchCode}})`;
return `try{${valCode}${appendSafe ? appendSafe() : ""}}catch(${errorVar}){${catchCode}}`;
};
var B_mergeWithPathPrepend = (
val,
parent,
locationVar,
appendSafe,
pureSince,
) =>
!val.path.length && locationVar === U
? B_merge(val)
: B_mergeWithCatch(
val,
(errorVar) => {
let segments = "";
for (let idx = 0; idx < parent.path.length; idx++) {
const segment = parent.path[idx];
segments += `${typeof segment === "string" ? inlinedValueFromString(segment) : segment},`;
}
if (locationVar !== U) segments += `${locationVar},`;
return `${errorVar}.path=[${segments}...${errorVar}.path]`;
},
appendSafe,
pureSince,
);
var noopOperation = (i) => i;
noopOperation["embedded"] = immutableEmptyArray;
var int32FormatValidation = (inputVar) =>
`${inputVar}<=2147483647&&${inputVar}>=-2147483648&&${inputVar}%1==0`;
var integerFormatValidation = (inputVar) => `${inputVar}%1==0`;
var typeofCondCache = {};
var typeofCond = (tag) =>
typeofCondCache[tag] ||
(typeofCondCache[tag] = (inputVar) => `typeof ${inputVar}==="${tag}"`);
var nanCond = (inputVar) => `Number.isNaN(${inputVar})`;
var isArrayCond = (inputVar) => `Array.isArray(${inputVar})`;
var objectTagCond = (inputVar) =>
`${typeofCond(objectTag)(inputVar)}&&${inputVar}&&!${isArrayCond(inputVar)}`;
var numberTagCond = (inputVar, allowNaN) => {
const t = typeofCond(numberTag)(inputVar);
return allowNaN ? t : `${t}&&${inputVar}==${inputVar}`;
};
var instanceofCond = (b, class_, inputVar) =>
`${inputVar} instanceof ${B_embed(b, class_)}`;
var typeofCheckCache = {};
var typeofCheck = (tag) =>
typeofCheckCache[tag] ||
(typeofCheckCache[tag] = {
c: typeofCond(tag),
f: failInvalidType,
});
var B_typeDecode = (input, tag, inputTagFlag) =>
inputTagFlag & 1
? B_refine(input, input.e, [typeofCheck(tag)])
: inputTagFlag & tagFlags[tag]
? input
: B_unsupportedDecode(input, input.s, input.e);
var numberDecoder = (input) => {
const inputTagFlag = tagFlags[input.s.type];
const expectedFormat = input.e.format;
if (inputTagFlag & 1) {
if (expectedFormat === "int32")
return B_refine(input, input.e, [
typeofCheck(numberTag),
{
c: int32FormatValidation,
f: failInvalidType,
},
]);
if (expectedFormat === "integer")
return B_refine(input, input.e, [
typeofCheck(numberTag),
{
c: integerFormatValidation,
f: failInvalidType,
},
]);
return B_refine(input, input.e, [
{
c: (v) => numberTagCond(v, !!(input.g.o & 2)),
f: failInvalidType,
},
]);
} else if (inputTagFlag & 2) {
const output = B_nextVar(input);
const inputVar = input.v();
output.cp = `let ${output.i}=+${inputVar};`;
output.vc = [
{
c: (_inputVar) =>
`${expectedFormat === "int32" ? int32FormatValidation(output.i) : expectedFormat === "integer" ? integerFormatValidation(output.i) : `${output.i}==${output.i}`}&&(${output.i}||${inputVar}.trim())`,
f: failInvalidType,
},
];
return output;
} else if (
inputTagFlag & 2048 &&
expectedFormat !== "int32" &&
expectedFormat !== "integer" &&
input.g.o & 2
)
return B_refine(input, input.e);
else if (inputTagFlag & 4) {
if (input.s.format !== expectedFormat && expectedFormat === "int32")
return B_refine(input, input.e, [
input.s.format === U
? {
c: int32FormatValidation,
f: failInvalidType,
}
: {
c: (inputVar) =>
`${inputVar}<=2147483647&&${inputVar}>=-2147483648`,
f: failInvalidType,
},
]);
if (expectedFormat === "integer" && input.s.format === U)
return B_refine(input, input.e, [
{
c: integerFormatValidation,
f: failInvalidType,
},
]);
}
return B_typeDecode(input, numberTag, inputTagFlag);
};
var float = initSchema(numberTag, numberDecoder);
var inputToString = (input, schema = string) =>
B_next(input, `""+${input.i}`, schema);
var stringDecoderFn = (input) => {
const inputTagFlag = tagFlags[input.s.type];
if (inputTagFlag & 3132 && isLiteral(input.s)) {
const const_ = "" + input.s.const;
const schema = baseSchema(stringTag, false, input.s.decoder);
schema.const = const_;
return B_next(input, `"${const_}"`, schema);
}
if (inputTagFlag & 1036) return inputToString(input, input.e);
return B_typeDecode(input, stringTag, inputTagFlag);
};
var string = initSchema(stringTag, stringDecoderFn);
var literalDecoder = (input) => {
const expectedSchema = input.e;
if (expectedSchema.noValidation && !input.u)
return B_nextConst(input, expectedSchema);
else if (isLiteral(input.s)) {
if (input.s.const === expectedSchema.const) return input;
else return B_nextConst(input, expectedSchema);
} else {
const schemaTagFlag = tagFlags[expectedSchema.type];
if (tagFlags[input.s.type] & 2 && schemaTagFlag & 3132) {
const stringConstSchema = baseSchema(stringTag, false, literalDecoder);
stringConstSchema.const = "" + expectedSchema.const;
const stringConstVal = B_nextConst(
input,
stringConstSchema,
stringConstSchema,
);
stringConstVal.vc = [
{
c: (inputVar) => `${inputVar}==="${stringConstSchema.const}"`,
f: failInvalidType,
},
];
return B_nextConst(stringConstVal, expectedSchema, expectedSchema);
} else if (schemaTagFlag & 2048)
return B_refine(input, expectedSchema, [
{
c: nanCond,
f: failInvalidType,
},
]);
else
return B_refine(input, expectedSchema, [
{
c: (inputVar) =>
`${inputVar}===${B_inlineConst(input, expectedSchema)}`,
f: failInvalidType,
},
]);
}
};
var unit = initSchema(undefinedTag, literalDecoder, (s2) => {
s2.const = U;
});
var nullLiteral = initSchema(nullTag, literalDecoder, (s2) => {
s2.const = null;
});
var nan = initSchema(nanTag, literalDecoder, (s2) => {
s2.const = NaN;
});
var Literal_parse = (value) => {
if (value === null) return nullLiteral;
else {
const tag = typeof value;
if (tag === undefinedTag) return unit;
else if (tag === numberTag && Number.isNaN(value)) return nan;
else if (tag === objectTag) {
const s2 = baseSchema(instanceTag, true, literalDecoder);
s2.class = value["constructor"];
s2.const = value;
return s2;
} else {
const s2 = baseSchema(tag, true, literalDecoder);
s2.const = value;
return s2;
}
}
};
var parse = (input) => {
let result = input;
let appliedEncoderRef = U;
let loopCount = 0;
while (!result.io || result.e.to) {
const appliedEncoder = appliedEncoderRef;
appliedEncoderRef = U;
const loopInput = result;
if (++loopCount > 50) panic("Loop count exceeded 50");
const defs = loopInput.e["$defs"];
if (defs)
loopInput.g.d
? Object.assign(loopInput.g.d, defs)
: (loopInput.g.d = defs);
if (loopInput.f & 1) {
const operationInputVar = loopInput.v();
const operationInput = B_scope(loopInput);
const operationOutput = parse(operationInput);
const operationCode = B_merge(operationOutput);
result =
operationInput.i !== operationOutput.i || operationCode !== ""
? B_next(
loopInput,
`${operationInputVar}.then(${operationInputVar}=>{${operationCode}return ${operationOutput.i}})`,
operationOutput.s,
operationOutput.e,
)
: B_refine(loopInput, operationOutput.s, U, operationOutput.e);
result.f |= 1;
result.io = true;
} else if (loopInput.io) {
const to2 = loopInput.e.to;
result = loopInput.e.parser
? loopInput.e.parser(loopInput)
: B_refine(result, U, U, to2);
} else {
const maybeEncoder = loopInput.s.encoder;
if (
maybeEncoder &&
maybeEncoder !== appliedEncoder &&
loopInput.s !== loopInput.e &&
loopInput.e.type !== unknownTag &&
!(
loopInput.e.noValidation &&
(loopInput.e.isJson || loopInput.e.type === undefinedTag)
)
)
result = maybeEncoder(loopInput, loopInput.e);
if (loopInput !== result) appliedEncoderRef = maybeEncoder;
else {
result = loopInput.e.decoder(loopInput);
if (!result.io) result = B_markOutput(result, result);
}
}
}
return result;
};
var parseDynamic = (input) => {
try {
return parse(input);
} catch (exn) {
const error = getOrRethrow(exn);
error.path = pathConcat(
input.p ? input.p.path : pathEmpty,
pathConcat(
pathConcat(input.path, pathDynamic),
error.path,
),
);
throw error;
}
};
var throwTail = (input, code, out, isAsync, flag, hasDefs) => {
if (flag & 1024) {
const errorOf = B_errorOf(input);
const issues = B_embedPure(input, (e2) => {
const error = errorOf(e2);
return {
issues: [
{
message: error.reason,
path: error.path.length ? error.path : U,
},
],
};
});
const v = isAsync ? B_varWithoutAllocation(input.g) : "";
const body = isAsync
? `${code}return ${out}.then(${v}=>({value:${v}}),${issues})`
: `${code}return {value:${out}}`;
if (!input.g.t) return body;
const e = B_varWithoutAllocation(input.g);
return `try{${body}}catch(${e}){return ${isAsync ? `Promise.resolve(${issues}(${e}))` : `${issues}(${e})`}}`;
}
return code === "" && out === operationArgVar && !(flag & 1)
? U
: `${code}return ${flag & 1 && !isAsync && !hasDefs ? `Promise.resolve(${out})` : out}`;
};
var emitTail = throwTail;
var compileDecoder = (schema, expected, flag, defs, node) => {
const input = B_operationArg(
isLiteral(schema) ? unknown : schema,
expected,
flag,
defs,
);
const output = parse(input);
const code = B_merge(output);
const isAsync = !!(output.f & 1);
if (node) {
node.y = isAsync;
node.t = output.t === true;
}
const body = emitTail(input, code, output.i, isAsync, flag, !!defs);
if (!body) return noopOperation;
const fn = new Function("e", "s", `return ${operationArgVar}=>{${body}}`)(
input.g.e,
s,
);
fn.embedded = input.g.e;
return fn;
};
var getOutputSchema = (schema) => {
while (schema.to) schema = schema.to;
return schema;
};
var reverseSwap = (mut, a, b) => {
const previous = mut[a];
mut[b] === U ? delete mut[a] : (mut[a] = mut[b]);
previous === U ? delete mut[b] : (mut[b] = previous);
};
var reverseDict = (dict2) => {
const reversed = Object.create(null);
for (const key in dict2) reversed[key] = reverse(dict2[key]);
return reversed;
};
Object.defineProperty(schemaPrototype, reversedKey, {
get() {
const schema = this;
let reversedHead = U;
let current = schema;
while (current) {
const mut = copySchema(current);
const next = mut.to;
reversedHead ? (mut.to = reversedHead) : delete mut.to;
const record = mut;
reverseSwap(record, "parser", "serializer");
reverseSwap(record, "refiner", "inputRefiner");
next && next.opens !== U ? (mut.opens = !next.opens) : delete mut.opens;
delete record["default"];
delete record["examples"];
if (mut.items) mut.items = mut.items.map(reverse);
if (mut.properties) mut.properties = reverseDict(mut.properties);
if (typeof mut.additionalItems === objectTag)
mut.additionalItems = reverse(mut.additionalItems);
if (mut.anyOf) {
const anyOf = mut.anyOf;
const has = {};
const newAnyOf = [];
for (let idx = 0; idx < anyOf.length; idx++) {
const s2 = anyOf[idx];
const reversed = reverse(s2);
newAnyOf.push(reversed);
setHas(has, reversed.type);
}
mut.has = has;
mut.anyOf = newAnyOf;
}
if (mut["$defs"]) mut["$defs"] = reverseDict(mut["$defs"]);
reversedHead = mut;
current = next;
}
const r = reversedHead;
valueOptions[valKey] = r;
Object.defineProperty(schema, reversedKey, valueOptions);
valueOptions[valKey] = schema;
Object.defineProperty(r, reversedKey, valueOptions);
return r;
},
});
var reverse = (schema) => schema.r;
var memoKey = "c";
var addOpNode = (schema, a, f, v) => {
const created = {
a,
f,
v,
n: schema[memoKey],
};
configurableValueOptions[valKey] = created;
Object.defineProperty(schema, memoKey, configurableValueOptions);
return created;
};
var compileChain = (cacheTarget, args, flag) => {
let schema = args[args.length - 1];
for (let i = args.length - 2; i >= 0; i--) {
const to2 = schema;
schema = updateOutput(args[i], (mut) => {
mut.to = to2;
if (mut.content !== U && mut.opens === U) mut.opens = true;
});
}
const f = compileDecoder(flag & 8 ? unknown : schema, schema, flag, U);
addOpNode(cacheTarget, args, flag, f);
return f;
};
var getOp = (opFlag, n, a0, a1, a2, a3) => {
const flag = opFlag | globalConfig.f;
let cacheTarget = a0;
let seq2 = a0.seq;
if (n > 1) {
if (a1.seq > seq2) ((seq2 = a1.seq), (cacheTarget = a1));
if (n > 2) {
if (a2.seq > seq2) ((seq2 = a2.seq), (cacheTarget = a2));
if (n > 3 && a3.seq > seq2) cacheTarget = a3;
}
}
let node = cacheTarget[memoKey];
while (node) {
const a = node.a;
if (
node.f === flag &&
a.length === n &&
a[0] === a0 &&
(n < 2 || a[1] === a1) &&
(n < 3 || a[2] === a2) &&
(n < 4 || a[3] === a3)
)
return node.v;
node = node.n;
}
return compileChain(cacheTarget, [a0, a1, a2, a3].slice(0, n), flag);
};
var nestedLoc = "BS_PRIVATE_NESTED_SOME_NONE";
var never_ = initSchema(neverTag, (input) => {
const output = B_refine(input, never_, U, never_);
output.cp = B_embedInvalidInput(input) + ";";
return output;
});
var instanceDecoder = (input) => {
const inputTagFlag = tagFlags[input.s.type];
return inputTagFlag & 1
? B_refine(input, input.e, [
{
c: (v) => instanceofCond(input, input.e.class, v),
f: failInvalidType,
},
])
: inputTagFlag & 8192 && input.s.class === input.e.class
? input
: B_unsupportedDecode(input, input.s, input.e);
};
var typeCheckCond = (input, schema, inputVar) => {
const tagFlag = tagFlags[schema.type];
if (tagFlag & 64) return objectTagCond(inputVar);
if (tagFlag & 128) return isArrayCond(inputVar);
if (tagFlag & 8192) return instanceofCond(input, schema.class, inputVar);
if (tagFlag & 4) return numberTagCond(inputVar, !!(input.g.o & 2));
if (tagFlag & 2048) return nanCond(inputVar);
if (tagFlag & 48) return `${inputVar}===${B_inlineConst(input, schema)}`;
if (tagFlag & 17418)
return schema.format === "env"
? `(typeof ${inputVar}==="string"||${inputVar}===void 0)`
: typeofCond(schema.type)(inputVar);
return "";
};
var isItemSchema = (x) => x !== U && typeof x !== "string";
var B_unrecognizedKeys = (input, keys, keyVar, decl) => {
const fail = B_failWithArg(
input,
(key) => ({
code: "unrecognized_key",
path: input.path,
reason: `Unrecognized key ${stringify(key)}`,
key,
}),
keyVar,
);
let cond = "";
for (let idx = 0; idx < keys.length; idx++) {
if (idx) cond += "&&";
cond += `${keyVar}!==${inlinedValueFromString(keys[idx])}`;
}
return (
`for(${decl}${keyVar} in ${input.v()})` +
(cond ? `if(${cond})` : "") +
fail +
";"
);
};
var B_fused = (input, expectedSchema, item) => {
const to2 = expectedSchema.to;
return to2 !== U && to2.fz !== U ? to2.fz(input, expectedSchema, item) : U;
};
var B_narrowJsonSourcedJsonString = (itemInput) => {
if (itemInput.s.isJson && itemInput.e.format === "json")
itemInput.s = unknown;
};
var B_makeContainerVal = (prev, schema) => ({
b: U,
p: U,
v: _notVar,
i: "",
s: schema,
io: U,
e: prev.e,
prev,
f: 0,
d: Object.create(null),
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: true,
path: prev.path,
g: prev.g,
o: U,
});
var makeObjectVal = (prev) =>
B_makeContainerVal(prev, {
type: objectTag,
required: [],
properties: Object.create(null),
additionalItems: "strict",
decoder: objectDecoder,
});
var makeArrayVal = (prev) =>
B_makeContainerVal(prev, {
type: arrayTag,
items: [],
additionalItems: "strict",
decoder: arrayDecoder,
});
var completeObjectVal = (objectVal) => {
const isArray = objectVal.s.type === arrayTag;
let inline = "";
let promiseAllContent = "";
let optionalSettingCode = U;
const keys = Object.keys(objectVal.d);
for (let idx = 0; idx < keys.length; idx++) {
const key = keys[idx];
const val = objectVal.d[key];
if (val.f & 1) promiseAllContent += val.i + ",";
if (val.o) {
const existingFn = optionalSettingCode;
optionalSettingCode = (objectVar) => {
return (
(existingFn === U ? "" : existingFn(objectVar)) +
(key === "__proto__"
? `if(${val.v()}!==void 0){${objectVar}={...${objectVar},["__proto__"]:${val.i}}}`
: `if(${val.v()}!==void 0){${inlinedProperty(objectVar, key, isArray)}=${val.i}}`)
);
};
} else
inline =
inline +
(isArray ? `${val.i}` : `${inlinedObjectKey(key)}:${val.i}`) +
",";
}
objectVal.i = isArray
? "[" + inline.slice(0, -1) + "]"
: "{" + inline.slice(0, -1) + "}";
if (promiseAllContent) {
promiseAllContent = promiseAllContent.slice(0, -1);
const operationInput = B_scope(objectVal);
operationInput.io = true;
const operationOutput = parse(operationInput);
let operationCode = B_merge(operationOutput);
let result = operationOutput.i;
if (optionalSettingCode !== U) {
const objectVar = B_varWithoutAllocation(objectVal.g);
operationCode =
operationCode +
`let ${objectVar}=${result};` +
optionalSettingCode(objectVar);
result = objectVar;
}
if (operationCode === "" && promiseAllContent === result)
objectVal.i = result;
else
objectVal.i = `Promise.all([${promiseAllContent}]).then(([${promiseAllContent}])=>{${operationCode}return ${result}})`;
objectVal.f |= 1;
objectVal.s = operationOutput.s;
objectVal.e = operationOutput.e;
objectVal.io = true;
return objectVal;
} else if (optionalSettingCode === U) return objectVal;
else {
const code = optionalSettingCode(objectVal.v());
const output = B_refine(objectVal);
output.cp = output.cp + code;
return output;
}
};
var arrayFactory = (item) => {
const mut = baseSchema(arrayTag, !!item.sr, arrayDecoder);
mut.additionalItems = item;
mut.items = immutableEmptyArray;
return mut;
};
var array = (item) =>
arrayFactory( definitionToSchema(item));
var arrayDecoder = (unknownInput) => {
const isUnion = unknownInput.u;
const expectedSchema = unknownInput.e;
const unknownInputTagFlag = tagFlags[unknownInput.s.type];
const expectedItems = expectedSchema.items;
const expectedLength = expectedItems.length;
let input;
if (unknownInputTagFlag & 129) {
const isArrayInput = unknownInputTagFlag & 128;
let schema;
if (!isArrayInput) schema = arrayFactory(unknown);
else schema = unknownInput.s;
const checks = [];
if (!isArrayInput)
checks.push({
c: isArrayCond,
f: failInvalidType,
});
const schemaAdditionalItems = schema.additionalItems;
if (
!(isItemSchema(schemaAdditionalItems)
? false
: schema.items.length === expectedLength)
) {
const expectedAdditionalItems2 = expectedSchema.additionalItems;
if (expectedAdditionalItems2 === "strict")
checks.push({
c: (inputVar) => `${inputVar}.length===${expectedLength}`,
f: failInvalidType,
});
else if (expectedAdditionalItems2 === "strip")
checks.push({
c: (inputVar) => `${inputVar}.length>=${expectedLength}`,
f: failInvalidType,
});
}
input = B_refine(unknownInput, schema, checks.length ? checks : U);
} else
input = B_unsupportedDecode(unknownInput, unknownInput.s, expectedSchema);
let output;
const expectedAdditionalItems = expectedSchema.additionalItems;
if (isItemSchema(expectedAdditionalItems)) {
const itemSchema = expectedAdditionalItems;
if (itemSchema === unknown) output = input;
else {
if (expectedLength === 0) {
const fused = B_fused(input, expectedSchema, itemSchema);
if (fused !== U) return B_markOutput(B_refine(input, fused), input);
}
const inputVar = input.v();
const iteratorVar = B_varWithoutAllocation(input.g);
const raiseCountBefore = input.g.t;
const itemInput = B_dynamicScope(input, iteratorVar);
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parseDynamic(itemInput);
const hasTransform = itemOutput.t;
const output2 = hasTransform
? B_next(
input,
`new Array(${inputVar}.length)`,
arrayFactory(itemOutput.s),
)
: B_refine(input, expectedSchema);
const itemCode = B_mergeWithPathPrepend(
itemOutput,
input,
iteratorVar,
hasTransform ? () => B_addKey(output2, iteratorVar, itemOutput) : U,
hasTransform ? U : raiseCountBefore,
);
if (hasTransform || itemCode !== "")
output2.cp =
output2.cp +
`for(let ${iteratorVar}=${expectedLength};${iteratorVar}<${inputVar}.length;++${iteratorVar}){${itemCode}}`;
if (itemOutput.f & 1)
output = B_asyncVal(output2, `Promise.all(${output2.i})`);
else output = output2;
}
} else {
const objectVal = makeArrayVal(input);
const fused = B_fused(input, expectedSchema);
const ai = expectedSchema.additionalItems;
let shouldRecreateInput =
fused === U &&
ai !== "strict" &&
(ai !== "strip" ||
isItemSchema(input.s.additionalItems) ||
input.s.items.length !== expectedLength);
for (let idx = 0; idx < expectedLength; idx++) {
const schema = expectedItems[idx];
const key = String(idx);
const itemInput = valGet(input, key);
itemInput.e = schema;
itemInput.io = false;
itemInput.u = isUnion;
if (fused !== U && !(isUnion && isLiteral(schema))) {
B_addObjectField(objectVal, key, itemInput);
continue;
}
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parse(itemInput);
if (isUnion && isLiteral(schema))
B_hoistChildChecks(input, itemOutput, key);
B_addObjectField(objectVal, key, itemOutput);
if (!shouldRecreateInput) shouldRecreateInput = itemOutput.t;
}
if (shouldRecreateInput) output = completeObjectVal(objectVal);
else {
const o = B_refine(input, fused || expectedSchema);
o.cp = objectVal.cp;
o.d = objectVal.d;
output = o;
}
}
return B_markOutput(output, input);
};
var objectTypeCheck = {
c: objectTagCond,
f: failInvalidType,
};
var objectDecoder = (unknownInput) => {
const isUnion = unknownInput.u;
const expectedSchema = unknownInput.e;
const unknownInputTagFlag = tagFlags[unknownInput.s.type];
let input;
if (unknownInputTagFlag & 65) {
const isObjectInput = unknownInputTagFlag & 64;
let schema;
if (!isObjectInput) {
const mut = baseSchema(objectTag, false, objectDecoder);
mut.properties = immutableEmptyObject;
mut.additionalItems = unknown;
schema = mut;
} else schema = unknownInput.s;
input = isObjectInput
? B_refine(unknownInput, schema)
: B_refine(unknownInput, schema, [objectTypeCheck]);
} else
input = B_unsupportedDecode(unknownInput, unknownInput.s, expectedSchema);
const expectedAdditionalItems = expectedSchema.additionalItems;
const dictItem = isItemSchema(expectedAdditionalItems)
? expectedAdditionalItems
: U;
const inputAdditionalItems = input.s.additionalItems;
const sourceIsDict = isItemSchema(inputAdditionalItems);
let output;
if (dictItem !== U && dictItem === unknown) output = input;
else if (dictItem !== U && sourceIsDict) {
const fused = B_fused(input, expectedSchema, dictItem);
if (fused !== U) return B_markOutput(B_refine(input, fused), input);
const inputVar = input.v();
const keyVar = B_varWithoutAllocation(input.g);
const raiseCountBefore = input.g.t;
const itemInput = B_dynamicScope(input, keyVar);
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parseDynamic(itemInput);
const hasTransform = itemOutput.t;
const output2 = hasTransform
? B_next(input, "{}", dictFactory(itemOutput.s))
: B_refine(input, expectedSchema);
const itemCode = B_mergeWithPathPrepend(
itemOutput,
input,
keyVar,
hasTransform ? () => B_addKey(output2, keyVar, itemOutput) : U,
hasTransform ? U : raiseCountBefore,
);
if (hasTransform || itemCode !== "")
output2.cp =
output2.cp + `for(let ${keyVar} in ${inputVar}){${itemCode}}`;
if (itemOutput.f & 1) {
const resolveVar = B_varWithoutAllocation(output2.g);
const rejectVar = B_varWithoutAllocation(output2.g);
const asyncParseResultVar = B_varWithoutAllocation(output2.g);
const counterVar = B_varWithoutAllocation(output2.g);
const outputVar = output2.v();
output = B_asyncVal(
output2,
`new Promise((${resolveVar},${rejectVar})=>{let ${counterVar}=Object.keys(${outputVar}).length;if(!${counterVar}){${resolveVar}(${outputVar})}for(let ${keyVar} in ${outputVar}){${outputVar}[${keyVar}].then(${asyncParseResultVar}=>{${outputVar}[${keyVar}]=${asyncParseResultVar};if(${counterVar}--===1){${resolveVar}(${outputVar})}},${rejectVar})}})`,
);
} else output = output2;
} else if (dictItem !== U) {
const itemSchema = dictItem;
const objectVal = makeObjectVal(input);
const keys = Object.keys(input.s.properties);
for (let idx = 0; idx < keys.length; idx++) {
const key = keys[idx];
const itemInput = valGet(input, key);
const source = itemInput.s;
const absent =
source.type === anyOfTag &&
source.has[undefinedTag] &&
!(tagFlags[itemSchema.type] & 817) &&
itemSchema.format !== "json";
if (absent) {
const target = copySchema(source);
target.anyOf = source.anyOf.map((variant) =>
variant.type === undefinedTag
? variant
: updateOutput(variant, (mut) => {
mut.to = itemSchema;
}),
);
target.perVariant = true;
itemInput.e = target;
} else itemInput.e = itemSchema;
itemInput.io = false;
itemInput.u = isUnion;
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parse(itemInput);
if (absent) itemOutput.o = true;
B_addObjectField(objectVal, key, itemOutput);
}
output = completeObjectVal(objectVal);
} else {
const properties = expectedSchema.properties;
const keys = Object.keys(properties);
const keysCount = keys.length;
const objectVal = makeObjectVal(input);
const ai = expectedSchema.additionalItems;
const fused = B_fused(input, expectedSchema);
let shouldRecreateInput =
fused === U &&
ai !== "strict" &&
(ai !== "strip" ||
sourceIsDict ||
Object.keys(input.s.properties).length !== keysCount);
const isJsonParent =
isItemSchema(inputAdditionalItems) && inputAdditionalItems.isJson;
for (let idx = 0; idx < keysCount; idx++) {
const key = keys[idx];
const schema = properties[key];
const itemInput = valGet(input, key);
itemInput.e = schema;
itemInput.io = false;
itemInput.u = isUnion;
if (isJsonParent && schema.type === anyOfTag && schema.has[undefinedTag])
itemInput.i = `(${itemInput.i}??null)`;
if (fused !== U && !(isUnion && isLiteral(schema))) {
B_addObjectField(objectVal, key, itemInput);
continue;
}
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parse(itemInput);
if (isUnion && isLiteral(schema))
B_hoistChildChecks(input, itemOutput, key);
B_addObjectField(objectVal, key, itemOutput);
if (!shouldRecreateInput) shouldRecreateInput = itemOutput.t;
}
if (ai === "strict" && isItemSchema(inputAdditionalItems) && fused === U) {
const keyVar = B_varWithoutAllocation(objectVal.g);
B_hoistDecl(input, keyVar);
objectVal.cp += B_unrecognizedKeys(input, keys, keyVar, "");
}
if (shouldRecreateInput) output = completeObjectVal(objectVal);
else {
const o = B_refine(input, fused || expectedSchema);
o.cp = objectVal.cp;
o.d = objectVal.d;
output = o;
}
}
return B_markOutput(output, input);
};
var dictFactory = (item) => {
const mut = baseSchema(objectTag, !!item.sr, objectDecoder);
mut.properties = immutableEmptyObject;
mut.additionalItems = item;
return mut;
};
var definitionToSchema = (definition) =>
isSchemaObject(definition)
? definition
: traverseDefinition(definition, (node) =>
isSchemaObject(node) ? node : U,
);
var traverseDefinition = (definition, onNode) => {
if (typeof definition === objectTag && definition !== null) {
const s2 = onNode(definition);
if (s2 !== U) return s2;
else if (Array.isArray(definition)) {
const node = definition;
for (let idx = 0; idx < node.length; idx++)
node[idx] = traverseDefinition(node[idx], onNode);
const items = node;
const mut = baseSchema(arrayTag, false, arrayDecoder);
mut.items = items;
mut.additionalItems = "strict";
return mut;
} else {
const proto = Object.getPrototypeOf(definition);
if (proto !== null && proto !== Object.prototype) {
const mut = baseSchema(instanceTag, true, literalDecoder);
mut.class = definition["constructor"];
mut.const = definition;
return mut;
} else {
const node = definition;
const fieldNames = Object.keys(node);
const length2 = fieldNames.length;
for (let idx = 0; idx < length2; idx++) {
const location = fieldNames[idx];
node[location] = traverseDefinition(node[location], onNode);
}
const mut = baseSchema(objectTag, false, objectDecoder);
mut.required = fieldNames;
mut.properties = node;
mut.additionalItems = globalConfig.a;
return mut;
}
}
} else return Literal_parse(definition);
};
var missingKeyEncoder = (input, target) => {
const item = input.s.anyOf[0];
const v = input.v();
const presentIn = B_scope(input);
presentIn.io = false;
presentIn.s = item;
presentIn.e = target;
presentIn.u = true;
const presentOut = parse(presentIn);
const presentCode = B_merge(presentOut);
const presentAssign = presentOut.i === v ? "" : `${v}=${presentOut.i};`;
const absentCode2 = isOptional(target)
? ""
: B_embedInvalidInput(input, target);
const output = B_nextVarOutput(input, v, getOutputSchema(target), target);
const presentBody = presentCode + presentAssign;
output.cp =
presentBody === ""
? absentCode2 === ""
? ""
: `${v}!==void 0||${absentCode2};`
: absentCode2 === ""
? `if(${v}!==void 0){${presentBody}}`
: `if(${v}!==void 0){${presentBody}}else{${absentCode2}}`;
return output;
};
var wrapDictMissingKeyLight = (s2) => {
const mut = baseSchema(anyOfTag, false, noopDecoder);
mut.anyOf = [s2, unit];
mut.has = { [undefinedTag]: true };
setHas(mut.has, s2.type);
mut.encoder = missingKeyEncoder;
mut.perVariant = true;
return mut;
};
var valGet = (parent, location) => {
const vals = parent.d ?? (parent.d = Object.create(null));
const existing = vals[location];
if (existing !== U) return B_scope(existing);
else {
let locationSchema;
if (parent.s.type === objectTag)
locationSchema = parent.s.properties[location];
else locationSchema = parent.s.items[Number(location)];
let schema;
if (locationSchema !== U) schema = locationSchema;
else {
const additionalItems = parent.s.additionalItems;
if (isItemSchema(additionalItems)) {
const s2 = additionalItems;
if (
parent.s.type === objectTag &&
s2.type !== unknownTag &&
!(tagFlags[s2.type] & 512) &&
!isOptional(s2)
)
schema = wrapDictMissingKeyLight(s2);
else schema = s2;
} else schema = B_unsupportedDecode(parent, parent.s, parent.e);
}
const accessor = inlinedProperty("", location, parent.s.type === arrayTag);
const item = {
b: U,
p: parent,
v: _notVarAtParent,
i: isLiteral(schema)
? B_inlineConst(parent, schema)
: parent.s.type === objectTag && location in Object.prototype
? `(Object.hasOwn(${parent.v()},${inlinedValueFromString(location)})?${parent.v()}${accessor}:void 0)`
: `${parent.v()}${accessor}`,
s: schema,
io: U,
e: schema,
prev: U,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathConcat(parent.path, [location]),
g: parent.g,
o: U,
};
vals[location] = item;
return item;
}
};
var unionRuntimeSame = (a, b) => a.type === b.type && a.class === b.class;
var unionSameType = (a, b) =>
a === b ||
(unionRuntimeSame(a, b) &&
!(tagFlags[a.type] & 768) &&
a.format === b.format);
var unionLiteralEqual = (a, b) => a === b || (a !== a && b !== b);
var unionOutput = (schema) => {
let output = schema;
while (output.type !== neverTag && output.to !== U) {
if (output.parser === B_neverSlot) return never_;
output = output.to;
}
return output;
};
var unionNeverLink = (schema) => {
for (let node = schema; node !== U && node.type !== neverTag; node = node.to)
if (node.parser === B_neverSlot) return true;
return false;
};
var unionIsTransparent = (schema) => {
if (schema.type !== anyOfTag) return false;
let fields = 0;
for (const _key in schema) fields++;
return fields === 6;
};
var unionTraits = (schema) => {
const tag = tagFlags[schema.type];
let traits = 0;
if (tag & 4864 || schema.parser !== U) return 15;
if (schema.refiner !== U || schema.inputRefiner !== U) traits |= 3;
else if (tag & 8384) traits |= 2;
if (schema.format !== U || isLiteral(schema)) traits |= 1;
const to2 = schema.to;
if (to2 !== U) {
if (to2 === schema || to2.parser !== U || tagFlags[to2.type] & 4864)
traits |= 15;
else if (
!(
to2.noValidation === true ||
tagFlags[to2.type] & 1 ||
unionRuntimeSame(schema, to2) ||
(to2.type === anyOfTag && unionMask(to2, 1, 0) & tag)
)
)
traits |= 9;
else traits |= unionTraits(to2);
}
const fields = schema.items || schema.properties;
for (const key in fields) {
const field = fields[key];
traits |= unionTraits(field);
}
if (typeof schema.additionalItems === "object")
traits |= unionTraits(schema.additionalItems);
return traits;
};
var unionIsNoop = (schema) => {
if (schema.to !== U || schema.parser !== U || tagFlags[schema.type] & 512)
return false;
const fields = schema.anyOf || schema.items || schema.properties;
for (const key in fields) if (!unionIsNoop(fields[key])) return false;
return (
typeof schema.additionalItems !== "object" ||
unionIsNoop(schema.additionalItems)
);
};
var unionFail = (schema, path, input, ...unionErrors) =>
B_throw(
B_makeInvalidInputDetails(
schema,
unknown,
path,
input,
unionErrors.length ? unionErrors : U,
),
);
var unionEmitChain = (cases, ctx) => {
if (cases.length === 1) {
const c = cases[0];
if (c.b === "" && c.c === "") return "";
if (c.b === "") return `if(!(${c.c})){${ctx.f("")}}`;
if (c.c === "") return c.b.endsWith(";") ? c.b : c.b + ";";
return `if(${c.c}){${c.b}}else{${ctx.f("")}}`;
}
let code = "";
let caught = false;
let exhaustive = false;
let open = false;
const attempt = (c, idx) => {
open = false;
if (c.b === "") return "break";
const body = c.b.endsWith(";") ? c.b : `${c.b};`;
if (c.f & 1 && (c.f & 8 || caught)) {
caught = open = true;
return `try{${body}break}catch(x){${c.f & 4 ? `x=${ctx.r()}(x);if(x.expected===${ctx.s()}){x=x.unionErrors;x&&(r||(r=[])).push(...x)}else{(r||(r=[])).push(x)}` : `(r||(r=[])).push(${ctx.r()}(x))`}${!(c.f & 8) && unconditional > idx ? `;${ctx.f(",...(r||[])")}` : ""}}`;
}
return `${body}break`;
};
let unconditional = -1;
for (let idx = 0; idx < cases.length; idx++)
if (cases[idx].c === "") unconditional = idx;
let last = "";
for (let idx = 0; idx < cases.length; idx++) {
const c = cases[idx];
const shared = c.c !== "" && c.c === last;
if (shared && !open) continue;
const arm = attempt(c, idx);
last = c.c;
if (shared) code = `${code.slice(0, -1)}${arm}}`;
else if (c.c === "") {
code += open ? arm : `${arm};`;
if (!open) {
exhaustive = true;
break;
}
} else code += arm === "break" ? `if(${c.c})break;` : `if(${c.c}){${arm}}`;
}
if (!exhaustive) code += ctx.f(caught ? ",...(r||[])" : "");
return `for(;;){${caught ? "let r;" : ""}${code}}`;
};
var unionOr = (cs) => {
const s2 = cs.map((c) => c.c).join("||");
return cs.length > 1 ? `(${s2})` : s2;
};
var unionNarrowSchema = (schema) => {
const tagFlag = tagFlags[schema.type];
const container = 192;
const narrow = baseSchema(schema.type, false, (input) => {
if (tagFlags[input.s.type] & 1)
return B_refine(input, input.e, [
{
c: (inputVar) => typeCheckCond(input, schema, inputVar),
f: failInvalidType,
},
]);
if (unionRuntimeSame(input.s, narrow))
return tagFlag & container ? B_refine(input, input.e) : input;
if (isLiteral(schema) && tagFlag & 1036) {
input.e = schema;
const output = schema.decoder(input);
input.e = narrow;
return output;
}
return schema.decoder(input);
});
narrow.encoder = schema.encoder;
if (schema.content !== U) setContent(narrow, schema.content);
if (tagFlag & 8192) narrow.class = schema.class;
else if (tagFlag & container) {
narrow.additionalItems = unknown;
if (tagFlag & 64) narrow.properties = immutableEmptyObject;
else narrow.items = immutableEmptyArray;
} else if (tagFlag & 2096) narrow.const = schema.const;
else if (tagFlag & 2 && schema.format !== U && schema.format !== "json") {
narrow.format = schema.format;
narrow.formatFlag = schema.formatFlag;
narrow.noValidation = schema.noValidation;
}
return narrow;
};
var unionWiden = (tagFlag, nan2) =>
tagFlag | (tagFlag & 8256 ? 8256 : tagFlag & tagFlags[numberTag] ? nan2 : 0);
var unionRefDef = (schema) => {
const defs = schema["$defs"],
ref = schema["$ref"];
if (defs === U || ref === U) return U;
const resolved = defs[ref.slice(ref.lastIndexOf("/") + 1)];
return resolved !== U && resolved !== schema ? resolved : U;
};
var unionMask = (schema, mode, nan2) => {
if (mode === 2) {
const resolved = unionRefDef(schema);
if (resolved !== U) return unionMask(resolved, 1, nan2);
}
const tagFlag = tagFlags[schema.type];
if (!mode && tagFlag & 32768) return 0;
if (mode && tagFlag & 256) {
let mask = 0;
const variants = schema.anyOf;
for (let i = 0; i < variants.length; i++)
mask |= unionMask(variants[i], 1, nan2);
return mask;
}
return tagFlag & 769 ? -1 : unionWiden(tagFlag, nan2);
};
var unionGroup = (member) => ({
m: member.m,
a: [member],
f: member.f & 16,
p: member.p,
o: false,
});
var unionDiscriminator = (schema) => {
if (isLiteral(schema)) return ["", schema.const];
const fields = schema.properties || schema.items;
for (const key in fields) {
const field = fields[key];
if (isLiteral(field)) return [key, field.const];
}
return U;
};
var unionDropNullish = (variants, other, outputSide) => {
if (
other === U ||
tagFlags[other.type] & 817 ||
other.format === "json" ||
other.format === "env"
)
return variants;
const kept = variants.filter(
(variant) =>
!(tagFlags[(outputSide ? unionOutput(variant) : variant).type] & 48),
);
return kept.length ? kept : variants;
};
var unionCheckPartial = (input, source, target, variants, outputSide) => {
const other = outputSide ? target : source;
let matched = U;
let unmatched = U;
for (let idx = 0; idx < variants.length; idx++) {
const variant = variants[idx];
const match = outputSide ? unionOutput(variant) : variant;
if (
variant.type === neverTag ||
(outputSide ? match.type === neverTag : unionNeverLink(variant))
)
continue;
if (unionSameType(other, match)) matched || (matched = variant);
else unmatched || (unmatched = variant);
}
if (matched !== U && unmatched !== U)
unionInvalid(input, source, target, unmatched, outputSide);
};
var unionPeer = (schema) =>
schema.anyOf?.find((variant) => !(tagFlags[variant.type] & 32816)) || schema;
var unionInvalid = (input, source, target, member, onSource) => {
const it = inputExpression(member);
const conversion = onSource
? `${it} -> ${/* @__PURE__ */ inputExpression(unionPeer(target))}`
: `${/* @__PURE__ */ inputExpression(unionPeer(source))} -> ${it}`;
return B_invalidOperation(
input,
`Ambiguous ${/* @__PURE__ */ inputExpression(source)} -> ${/* @__PURE__ */ inputExpression(target)}. Should ${it} be decoded or ignored? Choose with S.to for ${conversion}, or S.never -> ${it}`,
);
};
var unionAnalyze = (sourceMask, flags, sourceTag, variants, source, nan2) => {
const out = [];
const unknownSource = sourceTag & 1;
const sourceBoundary = sourceTag & 768;
const unionSource = sourceBoundary && sourceMask !== -1;
const sourceDiscriminator = unionDiscriminator(source);
const exact = flags & 1;
const broadObject = flags & 64;
const broadNumber = flags & tagFlags[numberTag];
const numberish = tagFlags[numberTag] | 2048;
for (let i = 0; i < variants.length; i++) {
const s2 = variants[i];
const tag = tagFlags[s2.type];
const inputMask = unionMask(s2, 1, nan2);
const d = unionDiscriminator(s2);
const same = unionRuntimeSame(source, s2);
const discriminatorDisjoint =
sourceDiscriminator !== U &&
d !== U &&
same &&
sourceDiscriminator[0] === d[0] &&
!unionLiteralEqual(sourceDiscriminator[1], d[1]);
const accepts =
!(tag & 32768) &&
!unionNeverLink(s2) &&
!discriminatorDisjoint &&
(!exact ||
(isLiteral(s2)
? unionLiteralEqual(s2.const, source.const)
: sourceMask & inputMask));
const native = sourceMask & tag;
const coerces = accepts && !unknownSource && !(unionSource ? native : same);
const output = unionOutput(s2);
const traits = unionTraits(s2);
const sourceDeopt = sourceBoundary && (!unionSource || coerces);
const effect =
output.type === neverTag
? 3
: traits & 4 || sourceDeopt
? 4
: coerces || traits & 8
? 2
: traits & 1 || tag & 9152
? 1
: 0;
out[i] = {
i,
s: s2,
m: accepts
? unknownSource
? inputMask
: unionSource
? native
? inputMask
: s2.type === undefinedTag && sourceMask & 32
? 32
: s2.type === nullTag && sourceMask & 16
? 16
: sourceMask & 2
? 2
: sourceMask
: sourceMask
: 0,
o: !!accepts && output.type !== neverTag,
e: effect,
f:
(traits & 7) |
(effect ? 1 : 0) |
(sourceDeopt ? 4 : 0) |
((!unknownSource && same) || tag & 37633 ? 16 : 0),
p:
(s2.type === objectTag && nestedLoc in s2.properties) ||
(broadObject && tag & 8320) ||
(broadNumber && tag & 2048)
? 0
: d !== U
? 1
: 2,
k: tag & 8192 ? s2.class : s2.format === "env" ? s2.format : s2.type,
n: unionNarrowSchema(s2),
r:
tag & 8256 ? 8256 : tag & numberish ? numberish : unionWiden(tag, nan2),
d,
};
}
return out;
};
var unionPlan = (members) => {
var _a;
const sequence = [];
const active = [];
const priority = [];
let total = 0;
let effects = 0;
for (let i = 0; i < members.length; i++) {
const member = members[i];
if (member.e > 1) effects |= member.m;
else if (!member.e) total |= member.m;
}
for (let i = 0; i < members.length; i++) {
const member = members[i];
if (
member.m === 0 ||
(member.e === 1 && !(member.f & 2) && !(member.m & (effects | ~total)))
)
continue;
const bucketed = member.r !== -1 && (member.m & ~member.r) === 0;
const compatible =
member.e < 2 ||
(member.d !== U && (member.e === 4 || member.d[0] !== ""));
let bucket = bucketed
? member.p === 0
? priority[member.r] || active[member.r]
: active[member.r]
: U;
let open = U;
let broad = false;
if (bucket !== U)
for (let j = 0; j < bucket.t.length; j++) {
const group = bucket.t[j];
const first = group.a[0];
broad || (broad = group.p === 2);
if (
open === U &&
compatible &&
group.o &&
first.k === member.k &&
(first.e < 2 === member.e < 2 ||
(first.d !== U && first.d[0] === member.d?.[0])) &&
(group.p === 0) === (member.p === 0)
)
open = group;
else if (group.o && group.m & member.m) group.o = false;
}
for (const key in active) {
const other = active[+key];
if (other !== bucket && other.m & member.m) delete active[+key];
}
if (!bucketed) {
for (const key in priority)
if (priority[+key].m & member.m) delete priority[+key];
sequence.push(unionGroup(member));
continue;
}
if (bucket !== U && open === U && member.p === 1 && broad) {
delete active[member.r];
bucket = U;
}
if (bucket === U) {
bucket = {
m: 0,
t: [],
};
active[member.r] = bucket;
priority[(_a = member.r)] || (priority[_a] = bucket);
sequence.push(bucket);
}
bucket.m |= member.m;
if (open !== U) {
open.a.push(member);
open.m |= member.m;
open.f &= -17;
} else {
const group = unionGroup(member);
group.o = compatible;
bucket.t.push(group);
}
if (!compatible) delete active[member.r];
}
const plan = [];
for (let i = 0; i < sequence.length; i++) {
const item = sequence[i];
if ("a" in item) plan.push(item);
else plan.push(...item.t.sort((a, b) => a.p - b.p));
}
const later = [];
let laterMask = 0;
let laterBroad = 0;
for (let i = plan.length - 1; i >= 0; i--) {
const group = plan[i];
let key = U;
let values;
for (let j = group.a.length - 1; j >= 0; j--) {
const member = group.a[j];
const d = member.d;
const conflict2 = d === U || key === false || (key !== U && key !== d[0]);
if (key !== U && (conflict2 || values.has(d[1]))) {
member.f |= 8;
group.f |= 2;
}
if (conflict2) key = false;
else {
key = d[0];
(values || (values = new Set())).add(d[1]);
}
}
const head = group.a[0];
const route = head.r;
const semantic = later[route];
let overlaps =
!!(laterMask & group.m) &&
(!!(laterBroad & group.m) ||
key === false ||
semantic === U ||
semantic === false ||
semantic[0] !== key);
if (!overlaps && semantic !== U && semantic !== false) {
for (const value of values)
if (semantic[1].has(value)) {
overlaps = true;
break;
}
}
if (
overlaps ||
(laterMask &&
tagFlags[head.s.type] & 37633 &&
(head.s.to !== U || head.s.parser !== U))
)
group.f |= 10;
if (route !== -1 && (group.m & ~route) === 0) {
if (key === false) later[route] = false;
else if (semantic === U) later[route] = [key, values];
else if (semantic !== false) {
if (semantic[0] !== key) later[route] = false;
else for (const value of values) semantic[1].add(value);
}
} else laterBroad |= group.m;
if (laterMask & group.m) group.f |= 32;
laterMask |= group.m;
}
return plan;
};
var unionEmit = (input, self, expectedSchema, plan, toPerCase, trustedSelf) => {
const initialInline = input.i;
let output = B_refine(input);
const awaitAsync = plan.some((group) => group.f & 2);
const outputBySource = [];
let salvaged = "";
let rethrow = "";
let expected = "";
const ctx = {
f: (caught) =>
`${B_embed(input, unionFail.bind(U, expectedSchema, input.path))}(${input.v()}${salvaged}${caught})`,
r: () => rethrow || (rethrow = B_embed(input, getOrRethrow)),
s: () => expected || (expected = B_embed(input, expectedSchema)),
};
const unionDTrusted = (member) => {
const d = member.d;
const tag = tagFlags[member.s.type];
for (const group of plan)
for (const m of group.a) {
if (m === member) continue;
if (
m.d !== U
? m.d[0] === d[0] && unionLiteralEqual(m.d[1], d[1])
: m.m & tag
)
return false;
}
return true;
};
const compile2 = (member, source, target) => {
const mark = input.g.t;
const caseInput = B_scope(source);
caseInput.u = true;
caseInput.t = source.t;
caseInput.io = false;
caseInput.e = member.s;
if (source.s === target.e) caseInput.s = member.n;
const trustedD =
trustedSelf &&
member.p === 1 &&
!(member.f & 8) &&
member.d[0] !== "" &&
unionDTrusted(member)
? member.d
: U;
if (trustedD !== U) caseInput.s = member.s;
let caseOut;
const options = input.g.o;
input.g.o |= 4;
try {
caseOut = parse(caseInput);
} catch (exn) {
if (!self.perVariant) throw exn;
salvaged += `,${B_embed(input, getOrRethrow(exn))}`;
return U;
} finally {
input.g.o = options;
}
if (member.o) outputBySource[member.i] = caseOut.s;
const cond = {
c: "",
h: [],
};
let body = B_merge(caseOut, cond);
const async = caseOut.f & 1;
output.f |= async;
if (caseOut.t) {
output.t = true;
const itemVar = target.v();
if (async || caseOut.i !== itemVar) {
body += `${itemVar}=${async && awaitAsync ? "await " : ""}${caseOut.i}`;
if (itemVar === operationArgVar) input.g.r = true;
}
}
if (trustedD !== U) {
const dSchema = (member.s.properties || member.s.items)[trustedD[0]];
const dRead = inlinedProperty(source.v(), trustedD[0]);
const dCond =
dSchema.type === nanTag
? `Number.isNaN(${dRead})`
: `${dRead}===${B_inlineConst(caseInput, dSchema)}`;
cond.c = cond.c ? `${dCond}&&${cond.c}` : dCond;
}
return {
c: cond.c,
b: body,
f:
(body !== "" && input.g.t !== mark ? 1 : 0) |
(async && awaitAsync ? 2 : 0) |
(member.f & 8),
};
};
const cases = [];
for (let i = 0; i < plan.length; i++) {
const group = plan[i];
if (group.a.length === 1 && group.f & 16) {
const c = compile2(group.a[0], input, input);
if (c !== U) {
c.f |= group.f & 8;
cases.push(c);
if (c.c === "" && c.b === "") break;
}
continue;
}
const mark = input.g.t;
const groupNarrow = group.a[0].n;
const narrowInput = B_scope(input);
narrowInput.io = false;
narrowInput.e = groupNarrow;
const narrow = parse(narrowInput);
if (tagFlags[groupNarrow.type] & 192) {
const resolved = unionRefDef(input.s);
const sourceVariant =
resolved !== U && resolved.anyOf !== U
? resolved.anyOf.find((v) => v.type === groupNarrow.type)
: U;
if (sourceVariant !== U) narrow.s = sourceVariant;
}
const inner = [];
for (let j = 0; j < group.a.length; j++) {
const c = compile2(group.a[j], narrow, narrowInput);
if (c !== U) {
inner.push(c);
if (c.c === "" && c.b === "") break;
}
}
if (!inner.length) continue;
const cond = {
c: "",
h: [],
};
let body;
let grouped = false;
if (inner.every((c) => c.b === "")) {
if (!inner.some((c) => c.c === "")) {
const fused = unionOr(inner);
body = B_merge(
B_refine(narrow, narrow.s, [
{
c: () => fused,
f: failInvalidType,
},
]),
cond,
);
} else body = B_merge(narrow, cond);
} else {
const narrowCode = B_merge(narrow, cond);
const only = inner.length === 1 ? inner[0] : U;
if (only !== U && narrowCode === "") {
if (only.c !== "") cond.c = cond.c ? `${cond.c}&&${only.c}` : only.c;
body = only.b;
} else {
if (inner.length > 1 && group.f & 32 && inner.every((c) => c.c)) {
const fused = unionOr(inner);
cond.c = cond.c ? `${cond.c}&&${fused}` : fused;
}
body = narrowCode + unionEmitChain(inner, ctx);
grouped = inner.length > 1;
}
}
cases.push({
c: cond.c,
b: body,
f:
(body !== "" && input.g.t !== mark ? 1 : 0) |
(inner.some((c) => c.f & 2) ? 2 : 0) |
(group.f & 8) |
(grouped ? 4 : 0),
});
if (body === "" && cond.c === "") break;
}
const noop = cases.every((c) => c.b === "") && cases.some((c) => c.c === "");
const pure =
!noop && cases.length > 0 && cases.every((c) => c.c !== "" && c.b === "");
const asyncDispatch = cases.some((c) => c.f & 2);
if (pure) {
const fused = unionOr(cases);
output = B_refine(
B_refine(
output,
output.s,
[
{
c: () => fused,
f: failInvalidType,
},
],
expectedSchema,
),
);
} else if (!noop) {
const dispatch2 = unionEmitChain(cases, ctx);
if (asyncDispatch) {
const itemVar = input.v();
output.i = `(async(${itemVar})=>{${dispatch2};return ${itemVar}})(${itemVar})`;
} else output.cp += dispatch2;
}
if (!asyncDispatch) output.i = input.i;
let out;
if (output.f & 1) {
output.i = `Promise.resolve(${output.i})`;
output.v = _notVar;
out = output;
} else if (
output.v === _var &&
input.cp === "" &&
output.cp === "" &&
!pure &&
initialInline === "i"
) {
input.hd = "";
input.v = _notVar;
input.i = initialInline;
out = input;
} else out = output;
const outputAnyOf = outputBySource.filter(Boolean);
out.s = outputAnyOf.length ? unionFactory(outputAnyOf) : never_;
if (toPerCase !== U) {
out.io = true;
out.e = unionOutput(toPerCase);
return out;
}
out.e = self;
return B_markOutput(out, input);
};
var unionDecoder = (input) => {
const self = input.e;
const toPerCase =
self.parser === U && self.to !== U && self.to.noValidation !== true
? self.to
: U;
let variants = self.anyOf;
if (
(input.io && input.e === input.s) ||
(input.s === self && toPerCase === U && variants.every(unionIsNoop)) ||
(input.s.type === anyOfTag &&
toPerCase === U &&
input.s.anyOf.every((inS, idx) => {
const s2 = variants[idx];
return (
s2 !== U &&
!(tagFlags[inS.type] & 9152) &&
inS.type === s2.type &&
unionLiteralEqual(inS.const, s2.const) &&
inS.to === U &&
s2.to === U
);
}))
)
return input;
const initialTagFlag = tagFlags[input.s.type];
const trustedSelf = input.s === self || self.tr;
if (initialTagFlag & 256 || (input.s.encoder === U && initialTagFlag & 512))
input.s = unknown;
if (variants.every(unionNeverLink))
B_invalidOperation(
input,
`Nothing decodes ${/* @__PURE__ */ inputExpression(self)}. Every member is S.never`,
);
const source = input.s;
variants = unionDropNullish(
unionDropNullish(variants, source, false),
toPerCase,
true,
);
let expected = self;
if (variants !== self.anyOf) {
expected = copySchema(self);
expected.anyOf = variants;
}
const nan2 = input.g.o & 2 ? 2048 : 0;
let flags = 0;
const sourceLiteral = isLiteral(source);
for (let i = 0; i < variants.length; i++) {
const member = variants[i];
if (
sourceLiteral &&
isLiteral(member) &&
unionLiteralEqual(member.const, source.const)
)
flags |= 1;
flags |= tagFlags[member.type] & (64 | tagFlags[numberTag]);
}
const sourceTag = tagFlags[source.type];
if (!(sourceTag & 1) && !(flags & 1))
unionCheckPartial(input, source, self, variants, false);
if (toPerCase !== U) {
const perCase = unionTargetOwns(toPerCase)
? variants.map((v) => (unionOutput(v).type === neverTag ? U : toPerCase))
: unionResolve(input, self, variants, toPerCase);
const attach =
self.refiner !== U || self.inputRefiner !== U
? unionRefinerAttacher(self)
: U;
variants = variants.map((variant, idx) => {
const to2 = perCase[idx];
return to2 === U && attach === U
? variant
: updateOutput(variant, (mut) => {
if (attach !== U) attach(mut);
if (to2 !== U) mut.to = to2;
});
});
}
return unionEmit(
input,
self,
expected,
unionPlan(
unionAnalyze(
unionMask(source, 2, nan2),
flags,
sourceTag,
variants,
source,
nan2,
),
),
toPerCase,
trustedSelf,
);
};
var unionRefinerAttacher = (self) => {
const cached = [];
return (mut) => {
for (let i = 0; i < 2; i++) {
const key = i ? "inputRefiner" : "refiner";
const source = self[key];
if (source !== U) {
const current = mut[key];
mut[key] = (input) => {
const shared = cached[i] || (cached[i] = source(input));
return current === U ? shared : current(input).concat(shared);
};
}
}
};
};
var unionRewrite = (input, variants, map) => {
const anyOf = [];
const has = {};
for (let idx = 0; idx < variants.length; idx++) {
const rewritten = map(variants[idx], idx);
anyOf.push(rewritten);
setHas(has, rewritten.type);
}
const mut = baseSchema(anyOfTag, false, unionDecoder);
mut.anyOf = anyOf;
mut.has = has;
mut.encoder = unionEncoder;
mut.perVariant = input.s.perVariant;
mut.tr = true;
return B_refine(input, unknown, U, mut);
};
var unionTargetOwns = (target) =>
target.noValidation === true ||
tagFlags[unionOutput(target).type] & 512 ||
(target.type === anyOfTag &&
target.anyOf.some((v) => tagFlags[v.type] & 512));
var unionEncoder = (input, target) => {
input.s;
if (unionTargetOwns(target)) return input;
const variants = unionDropNullish(input.s.anyOf, target, true);
if (target.perVariant && target.anyOf.length === variants.length) {
const targets = target.anyOf;
return targets.every((tv, idx) => tv === variants[idx])
? input
: unionRewrite(input, variants, (_variant, idx) => targets[idx]);
}
const resolved = unionResolve(input, input.s, variants, target);
if (resolved.every((to2) => to2 === U)) return input;
return unionRewrite(input, variants, (variant, idx) => {
const to2 = resolved[idx];
return to2 === U
? variant
: updateOutput(variant, (mut) => {
mut.to = to2;
});
});
};
var unionOpposite = (schema) =>
schema.type === undefinedTag
? nullTag
: schema.type === nullTag
? undefinedTag
: U;
var unionResolve = (input, source, variants, target) => {
if (source.perVariant) return variants.map(() => target);
if (unionIsTransparent(target))
return unionResolveToUnion(input, source, variants, target);
if (!(tagFlags[target.type] & 1) && !target.noValidation)
unionCheckPartial(input, source, target, variants, true);
return variants.map((variant) =>
unionOutput(variant).type === neverTag ? U : target,
);
};
var unionResolveToUnion = (input, source, variants, target) => {
const targets = target.anyOf;
const matches = [];
const covered = [];
let sourceNullish = 0;
for (let s2 = 0; s2 < variants.length; s2++) {
const sourceVariant = variants[s2];
const sourceOut = unionOutput(sourceVariant);
if (!(sourceVariant.type !== neverTag && sourceOut.type !== neverTag))
continue;
if (
sourceOut === target ||
(target.anyOf !== U && sourceOut.anyOf === target.anyOf)
) {
for (let t = 0; t < targets.length; t++) covered[t] = true;
continue;
}
const sameTyped = targets.filter(
(targetVariant, t) =>
targetVariant.type !== neverTag &&
!unionNeverLink(targetVariant) &&
unionSameType(sourceOut, targetVariant) &&
(covered[t] = true),
);
sourceNullish |= tagFlags[sourceOut.type] & 48;
if (sameTyped.length === 1) matches[s2] = sameTyped[0];
else if (sameTyped.length > 1)
matches[s2] =
tagFlags[sourceOut.type] & 9152 && sameTyped.includes(sourceOut)
? sourceOut
: unionFactory(sameTyped);
if (matches[s2] !== U) continue;
const opposite = unionOpposite(sourceOut);
if (opposite !== U)
matches[s2] = targets.find(
(candidate) =>
candidate.type === opposite &&
!unionNeverLink(candidate) &&
unionOutput(candidate).type !== neverTag,
);
if (matches[s2] === U) unionInvalid(input, source, target, sourceOut, true);
}
for (let t = 0; t < targets.length; t++) {
const targetVariant = targets[t];
const opposite = unionOpposite(targetVariant);
if (
targetVariant.type !== neverTag &&
!unionNeverLink(targetVariant) &&
!covered[t] &&
(opposite === U ||
unionOutput(targetVariant).type === neverTag ||
!(sourceNullish & tagFlags[opposite]))
)
unionInvalid(input, source, target, targetVariant, false);
}
return matches.map((matched, idx) => {
if (matched === U) return matched;
const sourceOut = unionOutput(variants[idx]);
return matched === sourceOut ||
(unionIsNoop(matched) &&
matched.refiner === U &&
matched.inputRefiner === U &&
matched.noValidation === U &&
(matched.const === U ||
unionLiteralEqual(matched.const, sourceOut.const)) &&
!(tagFlags[matched.type] & 9152) &&
unionSameType(matched, sourceOut))
? U
: matched;
});
};
var unionFactory = (schemas) => {
if (!schemas.length) return panic("S.union requires at least one item");
if (schemas.length === 1) return schemas[0];
const has = {};
const anyOf = [];
for (let idx = 0; idx < schemas.length; idx++) {
const schema = schemas[idx];
const nested = unionIsTransparent(schema) ? schema.anyOf : [schema];
for (let j = 0; j < nested.length; j++) {
const member = nested[j];
anyOf.push(member);
setHas(has, member.type);
}
}
const mut = baseSchema(anyOfTag, false, unionDecoder);
mut.anyOf = anyOf;
mut.encoder = unionEncoder;
mut.has = has;
return mut;
};
var internalRefine = (schema, makeRefiner) => {
return updateOutput(schema, (mut) => {
const refiner = makeRefiner(mut);
const existingRefiner = mut.refiner;
if (existingRefiner !== U)
mut.refiner = (input) => {
const arr = existingRefiner(input);
arr.push(...refiner(input));
return arr;
};
else mut.refiner = refiner;
});
};
var getMutErrorMessage = (mut) => {
const em = mut.errorMessage ? { ...mut.errorMessage } : {};
mut.errorMessage = em;
return em;
};
var codecTo = (schema, target, decode, encode) => {
return updateOutput(schema, (mut) => {
const opened = typeof decode === "boolean";
const parser = typeof decode === functionTag ? decode : U;
const serializer = typeof encode === functionTag ? encode : U;
if (serializer !== U || opened) {
const targetMut = copySchema(target);
if (serializer !== U) targetMut.serializer = serializer;
if (opened) targetMut.opens = decode;
mut.to = targetMut;
} else mut.to = target;
if (mut.content !== U && mut.opens === U) mut.opens = true;
if (parser !== U) mut.parser = parser;
});
};
var nullAsUnit = copyTo(nullLiteral, unit);
var Option_getWithDefault = (schema, default_) => {
return updateOutput(schema, (mut) => {
const anyOf = mut.anyOf;
if (anyOf === U)
return panic(
`Can't set default for ${/* @__PURE__ */ inputExpression(mut)}`,
);
const outputItems = [];
const originalItems = [];
for (let idx = 0; idx < anyOf.length; idx++) {
const variant = anyOf[idx];
const outputSchema = getOutputSchema(variant);
if (outputSchema.type !== undefinedTag) {
if (!outputItems.includes(outputSchema)) outputItems.push(outputSchema);
originalItems.push(variant);
}
}
const item =
outputItems.length === 0
? panic(`Can't set default for ${/* @__PURE__ */ inputExpression(mut)}`)
: outputItems.length === 1
? outputItems[0]
: unionFactory(outputItems);
if (default_.type === "value") {
const v = default_.value;
try {
getOp(0, 2, unknown, item)(v);
} catch (exn) {
const error = getOrRethrow(exn);
panic(
`Invalid default for ${/* @__PURE__ */ inputExpression(mut)}: ${error["message"]}`,
);
}
const originalItem =
originalItems.length === 1
? originalItems[0]
: unionFactory(originalItems);
try {
mut.default = getOp(
0,
1,
reverse(originalItem),
)(v);
} catch (_exn) {}
}
const decodeB = (input) => {
const target = input.e.to;
const output = B_next(
input,
default_.type === "value"
? B_inlineConst(input, Literal_parse(default_.value))
: `${B_embed(input, default_.callback)}()`,
target,
target,
);
if (default_.type === "value") output.v = _var;
return B_refine(output);
};
mut.anyOf = anyOf.map((variant) =>
getOutputSchema(variant).type === undefinedTag
? codecTo(variant, item, decodeB, B_neverSlot)
: variant,
);
});
};
var Option_getOr = (schema, defaultValue) =>
Option_getWithDefault(schema, {
type: "value",
value: defaultValue,
});
var Option_getOrWith = (schema, defaultCb) =>
Option_getWithDefault(schema, {
type: "callback",
callback: defaultCb,
});
var expects = (fnName, expected, got) =>
`S.${fnName} expects ${expected}, got ${got}`;
var assertNumericBound = (fnName, root, value) => {
const schema = getOutputSchema(root);
const tag = schema.type;
if (tag !== numberTag && tag !== bigintTag)
panic(
expects(
fnName,
"number | bigint schema",
inputExpression(schema),
),
);
if (
tag === bigintTag
? typeof value !== bigintTag
: typeof value !== numberTag || Number.isNaN(value)
)
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason: expects(
fnName,
inputExpression(schema),
stringify(value),
),
});
return schema;
};
var assertLengthBound = (fnName, root, value) => {
const schema = getOutputSchema(root);
if (schema.type !== stringTag && schema.type !== arrayTag)
panic(
expects(
fnName,
"string | array schema",
inputExpression(schema),
),
);
if (typeof value !== numberTag || !Number.isSafeInteger(value) || value < 0)
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason: expects(fnName, "integer >= 0", stringify(value)),
});
return schema;
};
var lit = (value) => (typeof value === bigintTag ? `${value}n` : `${value}`);
var sizeKey = (schema, upper) =>
schema.type === arrayTag
? upper
? "maxItems"
: "minItems"
: schema.type === instanceTag
? upper
? "maxSize"
: "minSize"
: upper
? "maxLength"
: "minLength";
var sizeMember = (schema) => {
const tag = schema.type;
return tag === instanceTag
? ".size"
: tag === stringTag || tag === arrayTag
? ".length"
: U;
};
var withBounds = (schema, base) => {
const written = schema.bounds ?? 0;
const member = sizeMember(schema);
const sized = member !== U;
const minKey = sized ? sizeKey(schema, false) : "minimum";
const maxKey = sized ? sizeKey(schema, true) : "maximum";
const exMin = written & 4 ? schema.exclusiveMinimum : U;
const exMax = written & 8 ? schema.exclusiveMaximum : U;
const high = exMax !== U ? exMax : written & 2 ? schema[maxKey] : U;
const low =
exMin !== U
? exMin
: written & 1 && !(sized && schema[minKey] === 0 && high !== 0)
? schema[minKey]
: U;
const mo = schema.multipleOf;
const subject0 = sized ? `${base}${member}` : base;
if (low === U && high === U)
return mo !== U ? `${subject0} % ${lit(mo)}` : base;
const subject = mo !== U ? `(${subject0} % ${lit(mo)})` : subject0;
if (low === U) return `${subject} ${exMax !== U ? "<" : "<="} ${lit(high)}`;
if (high === U) return `${subject} ${exMin !== U ? ">" : ">="} ${lit(low)}`;
return exMin === U && exMax === U && low === high
? `${subject} == ${lit(low)}`
: `${lit(low)} ${exMin !== U ? "<" : "<="} ${subject} ${exMax !== U ? "<" : "<="} ${lit(high)}`;
};
var setBoundExpression = (mut, schema) => {
if (schema.bounds === U && schema.multipleOf === U) {
const base = schema.expression;
mut.expression = (s2) =>
withBounds(
s2,
base !== U ? base(s2) : inputExpression(s2, true),
);
}
};
var exactDivisor = (d) => typeof d === bigintTag || Number.isInteger(d);
var multipleOfValidator = (d) => (value) => {
const ratio = value / d;
return (
Math.abs(ratio - Math.round(ratio)) <
Number.EPSILON * Math.max(Math.abs(ratio), 1)
);
};
var boundsRefiner = (input) => {
const s2 = input.e;
const written = s2.bounds ?? 0;
const checks = [];
const member = sizeMember(s2);
if (member !== U) {
const minKey = sizeKey(s2, false);
const maxKey = sizeKey(s2, true);
const min = written & 1 ? s2[minKey] : U;
const max = written & 2 ? s2[maxKey] : U;
const em = s2.errorMessage;
if (
min !== U &&
min === max &&
(em !== U ? em[minKey] : U) === (em !== U ? em[maxKey] : U)
)
checks.push({
c: (inputVar) => `${inputVar}${member}===${min}`,
f: B_failWithErrorMessage(minKey),
});
else {
if (min)
checks.push({
c: (inputVar) => `${inputVar}${member}>${min - 1}`,
f: B_failWithErrorMessage(minKey),
});
if (max !== U)
checks.push({
c: (inputVar) => `${inputVar}${member}<${max + 1}`,
f: B_failWithErrorMessage(maxKey),
});
}
} else {
const exMin = written & 4 ? s2.exclusiveMinimum : U;
const min = exMin !== U ? exMin : written & 1 ? s2.minimum : U;
if (min !== U)
checks.push({
c: (inputVar) => `${inputVar}${exMin !== U ? ">" : ">="}${lit(min)}`,
f: B_failWithErrorMessage(exMin !== U ? "exclusiveMinimum" : "minimum"),
});
const exMax = written & 8 ? s2.exclusiveMaximum : U;
const max = exMax !== U ? exMax : written & 2 ? s2.maximum : U;
if (max !== U)
checks.push({
c: (inputVar) => `${inputVar}${exMax !== U ? "<" : "<="}${lit(max)}`,
f: B_failWithErrorMessage(exMax !== U ? "exclusiveMaximum" : "maximum"),
});
const mo = s2.multipleOf;
if (mo !== U) {
let cond;
if (typeof mo === bigintTag)
cond = (inputVar) => `!(${inputVar}%${lit(mo)})`;
else if (exactDivisor(mo))
cond = (inputVar) => `${inputVar}%${lit(mo)}==0`;
else {
const embedded = B_embed(input, multipleOfValidator(mo));
cond = (inputVar) => `${embedded}(${inputVar})`;
}
checks.push({
c: cond,
f: B_failWithErrorMessage("multipleOf"),
});
}
}
return checks;
};
var updateBounds = (schema, update) =>
schema.bounds !== U || schema.multipleOf !== U
? updateOutput(schema, update)
: internalRefine(schema, (mut) => {
update(mut);
return boundsRefiner;
});
var carryMessage = (schema, key, maybeMessage) =>
maybeMessage === U || key === U
? schema
: updateOutput(schema, (mut) => {
getMutErrorMessage(mut)[key] = maybeMessage;
});
var setBoundMessage = (mut, schema, key, maybeMessage, replaced) => {
const existing = schema.errorMessage;
if (maybeMessage !== U) getMutErrorMessage(mut)[key] = maybeMessage;
else if (existing !== U && existing[key] !== U)
getMutErrorMessage(mut)[key] = U;
if (replaced !== U && existing !== U && existing[replaced] !== U)
getMutErrorMessage(mut)[replaced] = U;
};
var narrowsLower = (schema, value, exclusive) => {
const bound = value;
const inclusive = schema.minimum;
const strict2 = schema.exclusiveMinimum;
return (
(inclusive === U || (exclusive ? bound >= inclusive : bound > inclusive)) &&
(strict2 === U || bound > strict2)
);
};
var narrowsUpper = (schema, value, exclusive) => {
const bound = value;
const inclusive = schema.maximum;
const strict2 = schema.exclusiveMaximum;
return (
(inclusive === U || (exclusive ? bound <= inclusive : bound < inclusive)) &&
(strict2 === U || bound < strict2)
);
};
var narrowsSize = (current, value, upper) =>
upper ? current === U || value < current : value > (current ?? 0);
var conflict = (incoming, existing) => {
panic(
`${/* @__PURE__ */ inputExpression(incoming)} contradicts ${/* @__PURE__ */ inputExpression(existing)}`,
);
};
var asBound = (schema, key, bit, value) => {
const mut = {
...schema,
bounds: bit,
};
mut[key] = value;
setBoundExpression(mut, schema);
return mut;
};
var assertLower = (schema, value, exclusive) => {
const key = exclusive ? "exclusiveMinimum" : "minimum";
const bit = exclusive ? 4 : 1;
const bound = value;
const inclusive = schema.maximum;
const strict2 = schema.exclusiveMaximum;
if (inclusive !== U && (exclusive ? bound >= inclusive : bound > inclusive))
conflict(
asBound(schema, key, bit, value),
asBound(schema, "maximum", 2, inclusive),
);
if (strict2 !== U && bound >= strict2)
conflict(
asBound(schema, key, bit, value),
asBound(schema, "exclusiveMaximum", 8, strict2),
);
};
var assertUpper = (schema, value, exclusive) => {
const key = exclusive ? "exclusiveMaximum" : "maximum";
const bit = exclusive ? 8 : 2;
const bound = value;
const inclusive = schema.minimum;
const strict2 = schema.exclusiveMinimum;
if (inclusive !== U && (exclusive ? bound <= inclusive : bound < inclusive))
conflict(
asBound(schema, key, bit, value),
asBound(schema, "minimum", 1, inclusive),
);
if (strict2 !== U && bound <= strict2)
conflict(
asBound(schema, key, bit, value),
asBound(schema, "exclusiveMinimum", 4, strict2),
);
};
var assertSize = (schema, value, upper) => {
const otherKey = sizeKey(schema, !upper);
const other = schema[otherKey];
if (other !== U && (upper ? value < other : value > other))
conflict(
asBound(schema, sizeKey(schema, upper), upper ? 2 : 1, value),
asBound(schema, otherKey, upper ? 1 : 2, other),
);
};
var gte = (root, minValue, maybeMessage) => {
const schema = assertNumericBound("gte", root, minValue);
assertLower(schema, minValue, false);
if (!narrowsLower(schema, minValue, false)) {
const written = schema.bounds ?? 0;
return carryMessage(
root,
written & 4 ? "exclusiveMinimum" : written & 1 ? "minimum" : U,
maybeMessage,
);
}
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = ((schema.bounds ?? 0) & -5) | 1;
mut.minimum = minValue;
mut.exclusiveMinimum = U;
setBoundMessage(mut, schema, "minimum", maybeMessage, "exclusiveMinimum");
});
};
var lte = (root, maxValue, maybeMessage) => {
const schema = assertNumericBound("lte", root, maxValue);
assertUpper(schema, maxValue, false);
if (!narrowsUpper(schema, maxValue, false)) {
const written = schema.bounds ?? 0;
return carryMessage(
root,
written & 8 ? "exclusiveMaximum" : written & 2 ? "maximum" : U,
maybeMessage,
);
}
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = ((schema.bounds ?? 0) & -9) | 2;
mut.maximum = maxValue;
mut.exclusiveMaximum = U;
setBoundMessage(mut, schema, "maximum", maybeMessage, "exclusiveMaximum");
});
};
var minLength = (root, length2, maybeMessage) => {
const schema = assertLengthBound("minLength", root, length2);
assertSize(schema, length2, false);
const key = sizeKey(schema, false);
if (
!narrowsSize(schema[key], length2, false) &&
!(length2 === 0 && schema[key] === U)
)
return carryMessage(root, (schema.bounds ?? 0) & 1 ? key : U, maybeMessage);
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = (schema.bounds ?? 0) | 1;
mut[key] = length2;
setBoundMessage(mut, schema, key, maybeMessage);
});
};
var maxLength = (root, length2, maybeMessage) => {
const schema = assertLengthBound("maxLength", root, length2);
assertSize(schema, length2, true);
const key = sizeKey(schema, true);
if (!narrowsSize(schema[key], length2, true))
return carryMessage(root, (schema.bounds ?? 0) & 2 ? key : U, maybeMessage);
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = (schema.bounds ?? 0) | 2;
mut[key] = length2;
setBoundMessage(mut, schema, key, maybeMessage);
});
};
var nonEmpty = (schema, maybeMessage) =>
minLength(schema, 1, maybeMessage);
var stringFormat = (
format,
test,
flag,
expression,
) =>
initSchema(stringTag, stringDecoderFn, (s2) => {
const re = typeof test === "string" ? new RegExp(test, "i") : test;
s2.format = format;
if (expression) s2.expression = () => expression;
if (flag) s2.formatFlag = flag;
s2.refiner = (input) => {
return [
{
c: (inputVar) =>
`${B_embed(input, re)}${re instanceof RegExp ? ".test" : ""}(${inputVar})`,
f: B_failWithErrorMessage("format"),
},
];
};
});
var ipv4Pattern =
"(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
var ipv6Pattern = () =>
"(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|" +
ipv4Pattern +
")|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)";
var uriPattern = (schemeOptional, scheme) =>
"^(?:" +
(scheme || "[a-z][a-z0-9+\\-.]*") +
":)" +
schemeOptional +
"(?:\\/\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:" +
ipv6Pattern() +
"|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|" +
ipv4Pattern +
"|(?:[a-z0-9\\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\\?(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$";
var uri = stringFormat(
"uri",
uriPattern(""),
1,
);
var invalidDateRefine = (input) => {
return B_refine(input, input.e, [
{
c: (inputVar) => `!Number.isNaN(${inputVar}.getTime())`,
f: failInvalidType,
},
]);
};
var dateTimeString = initSchema(
stringTag,
stringDecoderFn,
(s2) => {
s2.format = "date-time";
s2.formatFlag = 1;
},
);
var date = initSchema(
instanceTag,
(input) => {
const inputTagFlag = tagFlags[input.s.type];
if (inputTagFlag & 2)
return invalidDateRefine(B_next(input, `new Date(${input.i})`, date));
else if (inputTagFlag & 1) return invalidDateRefine(instanceDecoder(input));
else if (inputTagFlag & 8192 && input.s.class === date.class) return input;
else return B_unsupportedDecode(input, input.s, input.e);
},
(s2) => {
s2.class = Date;
s2.encoder = (input, target) => {
if (tagFlags[target.type] & 2) {
if (input.s.noValidation)
return parse(
B_refine(
B_next(input, `${input.i}.toISOString()`, dateTimeString, target),
),
);
const output = B_nextVar(input, dateTimeString, target);
output.cp = `let ${output.i};try{${output.i}=${input.v()}.toISOString()}catch(_){${B_embedInvalidInput(input, input.s)}}`;
return parse(B_refine(output));
} else return input;
};
},
);
var panicArity = () =>
panic(
"Expected at most 3 schemas and a value. Use .with(S.to, ...) for a longer chain",
);
var dispatch = (n, a, b, c, d, tail, rev, flag) => {
if (n > 4) panicArity();
let data = U;
let immediate = !isOwnSchema(a);
if (immediate) {
((data = a), (a = b), (b = c), (c = d), n--);
if (n < 1 || !isOwnSchema(a)) panicNotSchema();
}
const k = n > 1 && isOwnSchema(b) ? (n > 2 && isOwnSchema(c) ? 3 : 2) : 1;
if (n > k) {
if (immediate || n > k + 1)
panic("Expected a Sury schema. The data goes first or last");
data = k > 2 ? (isOwnSchema(d) ? panicArity() : d) : k > 1 ? c : b;
immediate = true;
}
const first = rev ? reverse(a) : a;
const op =
k > 2
? getOp(flag, tail ? 4 : 3, first, b, c, tail)
: k > 1
? getOp(flag, tail ? 3 : 2, first, b, tail)
: getOp(flag, tail ? 2 : 1, first, tail);
return immediate ? op(data) : op;
};
function parseOrThrow(a, b, c, d) {
return dispatch(arguments.length, a, b, c, d, U, false, 8);
}
var getStandardJSONSchema = (schema, options, isOutput2) => {
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason:
"~standard.jsonSchema requires S.enableStandardJSONSchema() to be called first",
});
};
Object.defineProperty(schemaPrototype, "toString", {
value: function () {
const input = inputExpression(this);
const output = inputExpression(
reverse(this),
);
return `Schema<${input === output ? input : `${input}, ${output}`}>`;
},
});
Object.defineProperty(schemaPrototype, "~standard", {
get: function () {
const schema = this;
let opFlag = U;
let validateOp;
const standard = {
version: 1,
vendor,
validate: (input) => {
if (opFlag !== globalConfig.f) {
validateOp = getOp(1537, 2, unknown, schema);
opFlag = globalConfig.f;
}
return validateOp(input);
},
jsonSchema: {
input: (options) => getStandardJSONSchema(schema, options, false),
output: (options) => getStandardJSONSchema(schema, options, true),
},
};
valueOptions[valKey] = standard;
Object.defineProperty(schema, "~standard", valueOptions);
return standard;
},
});
var union = (values) =>
unionFactory(values.map(definitionToSchema));
var nullable2 = (definition, maybeOr) => {
const schema = definitionToSchema(definition);
if (maybeOr !== U) {
const schema2 = unionFactory([schema, nullAsUnit]);
if (typeof maybeOr === functionTag)
return Option_getOrWith(schema2, maybeOr);
else return Option_getOr(schema2, maybeOr);
} else return unionFactory([schema, nullLiteral]);
};
const imageSchema = definitionToSchema({
id: float,
created: date,
title: string.with(nonEmpty).with(maxLength, 100),
type: union(["jpg", "png"]),
size: float,
url: uri,
});
const ratingSchema = definitionToSchema({
id: float,
stars: float.with(gte, 1).with(lte, 5),
title: string.with(nonEmpty).with(maxLength, 100),
text: string.with(nonEmpty).with(maxLength, 1e3),
images: array(imageSchema),
});
parseOrThrow(
definitionToSchema({
id: float,
created: date,
title: string.with(nonEmpty).with(maxLength, 100),
brand: string.with(nonEmpty).with(maxLength, 30),
description: string.with(nonEmpty).with(maxLength, 500),
price: float.with(gte, 1).with(lte, 1e4),
discount: float.with(gte, 1).with(lte, 100).with(nullable2),
quantity: float.with(gte, 0).with(lte, 10),
tags: array(string.with(nonEmpty).with(maxLength, 30)),
images: array(imageSchema),
ratings: array(ratingSchema),
}),
)({});
var pathEmpty = [];
var pathDynamic = ["[]"];
var inlineUnsafeRe = /["\\\n\r]/;
var inlinedValueFromString = (str) => (inlineUnsafeRe.test(str) ? JSON.stringify(str) : `"${str}"`);
var jsIdentRe = /^[A-Za-z_$][\w$]*$/;
var inlinedObjectKey = (key) =>
key === "__proto__" ? '["__proto__"]' : jsIdentRe.test(key) ? key : inlinedValueFromString(key);
var inlinedProperty = (obj, key, numeric) =>
numeric && /^\d+$/.test(key)
? `${obj}[${key}]`
: key === "__proto__" || !jsIdentRe.test(key)
? `${obj}[${inlinedValueFromString(key)}]`
: `${obj}.${key}`;
var pathConcat = (path, concatedPath) =>
path.length ? (concatedPath.length ? path.concat(concatedPath) : path) : concatedPath;
var pathToText = (path) => {
let text = "";
for (let idx = 0; idx < path.length; idx++) {
const segment = path[idx];
text +=
typeof segment !== "string"
? `[${String(segment)}]`
: /^\d+$/.test(segment)
? `[${segment}]`
: segment === "[]"
? segment
: jsIdentRe.test(segment)
? text
? `.${segment}`
: segment
: `[${inlinedValueFromString(segment)}]`;
}
return text;
};
var stringTag = "string";
var numberTag = "number";
var bigintTag = "bigint";
var booleanTag = "boolean";
var symbolTag = "symbol";
var nullTag = "null";
var undefinedTag = "undefined";
var nanTag = "nan";
var functionTag = "function";
var instanceTag = "instance";
var arrayTag = "array";
var objectTag = "object";
var anyOfTag = "anyOf";
var neverTag = "never";
var unknownTag = "unknown";
var refTag = "ref";
var tagFlags = {
[unknownTag]: 1,
[stringTag]: 2,
[numberTag]: 4,
[booleanTag]: 8,
[undefinedTag]: 16,
[nullTag]: 32,
[objectTag]: 64,
[arrayTag]: 128,
[anyOfTag]: 256,
[refTag]: 512,
[bigintTag]: 1024,
[nanTag]: 2048,
[functionTag]: 4096,
[instanceTag]: 8192,
[neverTag]: 32768,
[symbolTag]: 16384,
};
var vendor = "sury";
var s = Symbol(vendor);
vendor + "";
var U = void 0;
var immutableEmptyArray = [];
var immutableEmptyObject = Object.create(null);
var isSchemaObject = (obj) => typeof obj === objectTag && obj !== null && "~standard" in obj;
var isLiteral = (schema) => "const" in schema;
var isOptional = (schema) =>
schema.type === undefinedTag || (schema.type === anyOfTag && undefinedTag in schema.has);
var namedConstructor = (unknown2) => {
const ctor = Object.getPrototypeOf(unknown2)?.constructor;
return ctor !== Object && ctor?.name;
};
var stringifyLeaf = (unknown2) => {
const tagFlag = tagFlags[typeof unknown2];
if (tagFlag & 16) return undefinedTag;
else if (tagFlag & 4160)
return unknown2 === null
? nullTag
: Array.isArray(unknown2)
? `Array(${unknown2.length})`
: namedConstructor(unknown2) || objectTag;
else if (tagFlag & 2) return `"${unknown2}"`;
else if (tagFlag & 1024) return `${unknown2}n`;
else return unknown2.toString();
};
var stringify = (unknown2) => {
if (unknown2 !== null && typeof unknown2 === objectTag) {
if (Array.isArray(unknown2)) {
const items = unknown2;
let body = "";
for (let idx = 0; idx < items.length; idx++) {
if (idx === 5) {
body += ", ...";
break;
}
body += (idx ? ", " : "") + stringifyLeaf(items[idx]);
}
return `[${body}]`;
}
if (!namedConstructor(unknown2)) {
const dict2 = unknown2;
let body = "";
let count = 0;
for (const key in dict2) {
if (count++ === 5) {
body += "... ";
break;
}
body += key + ": " + stringifyLeaf(dict2[key]) + "; ";
}
return body ? `{ ${body}}` : "{}";
}
}
return stringifyLeaf(unknown2);
};
var inputExpression = (schema, skipOverride) => {
if (schema.name) return schema.name;
else if (schema.const !== U) return stringify(schema.const);
else if (schema.expression && !skipOverride) return schema.expression(schema);
else if (schema.anyOf !== U) {
const anyOf = schema.anyOf;
const seen = new Set();
let body = "";
for (let idx = 0; idx < anyOf.length; idx++) {
const expression = inputExpression(anyOf[idx]);
if (!seen.has(expression)) {
seen.add(expression);
body += (body ? " | " : "") + expression;
}
}
return body;
} else if (schema.type === objectTag) {
const properties = schema.properties;
const additionalItems = schema.additionalItems;
let body = "";
for (const location in properties)
body += location + ": " + inputExpression(properties[location]) + "; ";
if (typeof additionalItems === objectTag)
body += "[key: string]: " + inputExpression(additionalItems) + "; ";
return body ? `{ ${body}}` : "{}";
} else if (schema.type === arrayTag) {
const additionalItems = schema.additionalItems;
if (typeof additionalItems === objectTag) {
const item = additionalItems;
const itemName = inputExpression(item);
return (
(item.type === anyOfTag || item.bounds !== U || item.multipleOf !== U
? `(${itemName})`
: itemName) + "[]"
);
}
const items = schema.items;
let body = "";
for (let idx = 0; idx < items.length; idx++)
body += (idx ? ", " : "") + inputExpression(items[idx]);
return `[${body}]`;
} else if (schema.format) return schema.format;
else if (schema.type === instanceTag) return schema.class.name;
else return schema.type;
};
var Schema = function () {};
var schemaPrototype = Object.create(null);
Object.defineProperty(schemaPrototype, "with", {
value(fn, ...args) {
return fn(this, ...args);
},
});
Schema.prototype = schemaPrototype;
var reversedKey = "r";
var SelfReverseSchema = function () {};
var selfReversePrototype = Object.create(schemaPrototype);
Object.defineProperty(selfReversePrototype, reversedKey, {
get() {
return this;
},
});
Object.defineProperty(selfReversePrototype, "sr", { value: true });
SelfReverseSchema.prototype = selfReversePrototype;
var isOwnSchema = (value) => {
const proto = typeof value === objectTag && value && Object.getPrototypeOf(value);
return proto === schemaPrototype || proto === selfReversePrototype;
};
var panicNotSchema = () => panic("Expected a Sury schema");
var seq = 1;
var exnId = {};
var SuryError = class extends Error {
constructor(params) {
super();
Object.assign(this, params);
}
get message() {
return formatErrorMessage(this);
}
get _1() {
return this;
}
get RE_EXN_ID() {
return exnId;
}
};
Object.defineProperty(SuryError.prototype, "name", { value: "SuryError" });
Object.defineProperty(SuryError.prototype, "s", { value: s });
var getOrRethrow = (exn) => {
if (exn && exn.s === s) return exn;
throw exn;
};
var panic = (message) => {
throw new Error(`[Sury] ${message}`);
};
var formatErrorMessage = (error) =>
`${error.path.length ? `Failed at ${/* @__PURE__ */ pathToText(error.path)}: ` : ""}${error.reason}`;
var globalConfig = {
m: formatErrorMessage,
d: U,
a: "strip",
f: 0,
};
var valueOptions = {};
var configurableValueOptions = { configurable: true };
var valKey = "value";
var baseSchema = (tag, selfReverse, decoder) => {
const schema = new (selfReverse ? SelfReverseSchema : Schema)();
schema.type = tag;
schema.seq = seq++;
schema.decoder = decoder;
return schema;
};
var noopDecoder = (input) => input;
var initSchema = (tag, decoder, init) => {
const schema = baseSchema(tag, true, decoder);
return (init?.(schema), schema);
};
var unknown = baseSchema(unknownTag, true, noopDecoder);
var copySchema = (schema) => {
const c = Object.assign(new Schema(), schema);
c.seq = seq++;
if (schema.content !== U) setContent(c, schema.content);
if (schema.bc !== U) setBytesCodec(c, schema.bc);
return c;
};
var copyTo = (from, to2) => {
const mut = copySchema(from);
mut.to = to2;
return mut;
};
var setContent = (schema, content) => {
valueOptions[valKey] = content;
Object.defineProperty(schema, "content", valueOptions);
};
var setBytesCodec = (schema, codec) => {
valueOptions[valKey] = codec;
Object.defineProperty(schema, "bc", valueOptions);
};
var updateOutput = (schema, fn) => {
const root = copySchema(schema);
let mut = root;
while (mut.to) {
const next = copySchema(mut.to);
mut.to = next;
mut = next;
}
fn(mut);
return root;
};
var setHas = (has, tag) => {
has[tagFlags[tag] & 768 ? unknownTag : tag] = true;
};
function _var() {
return this.i;
}
var _linkVar = function () {
return (this.b || this.prev).v();
};
function _notVarBeforeValidation() {
const val = this;
const v = B_varWithoutAllocation(val.g);
val.cp = `let ${v}=${val.i};`;
val.i = v;
val.v = _var;
return v;
}
function _notVarAtParent() {
const val = this;
const parent = val.p;
if (parent.fz) {
val.v = _var;
return val.i;
}
const v = B_varWithoutAllocation(val.g);
B_hoistDecl(parent, `${v}=${val.i}`);
val.v = _var;
val.i = v;
return v;
}
function _notVar() {
const val = this;
if (val.fz) {
val.v = _var;
val.i = `(${val.i})`;
return val.i;
}
const v = B_varWithoutAllocation(val.g);
if (val.prev !== U) {
if (val.i === "") val.cp = `let ${v};` + val.cp;
else val.cp += `let ${v}=${val.i};`;
} else B_hoistDecl(val, val.i === "" ? v : `${v}=${val.i}`);
val.v = _var;
val.i = v;
return v;
}
var operationArgVar = "i";
var failInvalidType = (input) => {
const em = input.e.errorMessage;
return B_invalidInputBuilder(
U,
U,
em && (input.e.format !== U && em.format !== U ? em.format : em.type !== U ? em.type : em._),
)(input);
};
var B_embed = (b, value) => (b.g.t++, B_embedPure(b, value));
var B_embedPure = (b, value) => `e[${b.g.e.push(value) - 1}]`;
var B_inlineConst = (b, schema) => {
const tagFlag = tagFlags[schema.type],
const_ = schema.const;
return tagFlag & 16
? "void 0"
: tagFlag & 2
? inlinedValueFromString(const_)
: tagFlag & 1024
? const_ + "n"
: tagFlag & 28672
? B_embedPure(b, schema.const)
: const_;
};
var B_varWithoutAllocation = (g) => `v${++g.v}`;
var B_hoistDecl = (owner, decl) => {
owner.hd += (owner.hd && ",") + decl;
};
var B_operationArg = (schema, expected, flag, defs) => {
return {
b: U,
p: U,
v: _var,
i: operationArgVar,
s: schema,
io: U,
e: expected,
prev: U,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathEmpty,
g: {
d: defs,
o: flag,
e: [],
v: -1,
t: 0,
},
o: U,
};
};
var B_throw = (errorDetails) => {
throw new SuryError(errorDetails);
};
var B_unsupportedDecode = (b, from, target) =>
B_throw({
code: "unsupported_decode",
from,
to: target,
reason: `Can't decode ${/* @__PURE__ */ inputExpression(from)} -> ${/* @__PURE__ */ inputExpression(target)}. Define custom codec with S.to`,
path: b.path,
});
var B_failWithArg = (b, fn, arg) =>
`${B_embed(b, (a) => {
B_throw(fn(a));
})}(${arg})`;
var B_markThrow = (b) => {
b.g.t++;
};
var B_foreignDetails = (input, to2, cause) => ({
code: "invalid_conversion",
from: input.s,
to: to2,
cause,
path: input.path,
reason: cause instanceof Error ? ("" + cause).replace(/^Error: /, "") : stringify(cause),
});
var B_errorOf = (input) => {
let to2 = input.e;
while (to2.to) to2 = to2.to;
return (e) => (e && e.s === s ? e : new SuryError(B_foreignDetails(input, to2, e)));
};
var B_makeInvalidInputDetails = (expected, received, path, input, unionErrors, reasonOverride) => {
let reasonRef = reasonOverride;
if (reasonRef === U) {
const expectedExpression = inputExpression(expected);
const receivedExpression = stringify(input);
reasonRef = `Expected ${expectedExpression}, received ${expectedExpression === receivedExpression ? "invalid " : ""}${receivedExpression}`;
}
if (unionErrors) {
const seenReasons = new Set();
for (let idx = 0; idx < unionErrors.length; idx++) {
const caseError = unionErrors[idx];
const line = `
- ${caseError.path.length ? `At ${/* @__PURE__ */ pathToText(caseError.path)}: ` : ""}${caseError.reason.split("\n").join("\n ")}`;
if (!seenReasons.has(line)) {
seenReasons.add(line);
reasonRef += line;
}
}
}
return {
code: "invalid_input",
expected,
received,
path,
reason: reasonRef,
unionErrors,
input,
};
};
var B_invalidInputBuilder =
(expected, extraPath = pathEmpty, reasonOverride) =>
(input) => {
const path = pathConcat(input.path, extraPath);
return (value) =>
B_makeInvalidInputDetails(
expected ?? input.e,
(input.prev || input).s,
path,
value,
U,
reasonOverride,
);
};
var B_failWithErrorMessage = (key, defaultMessage) => (input) => {
const em = input.e.errorMessage;
const m = em?.[key] ?? em?.["_"] ?? defaultMessage;
return m !== U ? B_invalidInputBuilder(U, U, m)(input) : failInvalidType(input);
};
var B_embedInvalidInput = (input, expected = input.e) =>
B_failWithArg(input, B_invalidInputBuilder(expected)(input), input.v());
var B_emitChecks = (val, inputVar) => {
const checks = val.vc;
let out = "",
i = 0,
len = checks.length;
while (i < len) {
const head = checks[i],
fail = head.f;
let cond = head.c(inputVar);
i++;
while (i < len && checks[i].f === fail) {
cond += "&&" + checks[i].c(inputVar);
i++;
}
out += `${cond}||${B_failWithArg(val, fail(val), inputVar)};`;
}
return out;
};
var B_merge = (val, out) => {
let current = val,
code = "";
while (current !== U) {
const val2 = current;
current = val2.prev;
let currentCode = "";
if (val2.vc) {
if (out && (!val2.t || (!val2.prev.t && val2.cp === ""))) {
const inputVar = (current || val2).v();
const checks = val2.vc;
let hoisted = "";
for (let i = 0; i < checks.length; i++) {
const check = checks[i];
const condCode = check.c(inputVar);
if (check.f === failInvalidType) hoisted = hoisted ? `${hoisted}&&${condCode}` : condCode;
else if (val2.e.noValidation !== true)
currentCode += `${condCode}||${B_failWithArg(val2, check.f(val2), inputVar)};`;
}
if (hoisted) {
out.c = out.c ? `${hoisted}&&${out.c}` : hoisted;
out.h.unshift({
v: val2,
i: inputVar,
c: hoisted,
});
}
} else if (val2.e.noValidation !== true)
currentCode = B_emitChecks(val2, (current || val2).v());
}
if (val2.hd) currentCode += `let ${val2.hd};`;
val2.fz = true;
code = val2.cp + currentCode + code;
}
return code;
};
var B_linkVar = (val, nextVal) => {
const get = val.v.bind(val);
val.v = () => ((nextVal.i = get()), (nextVal.v = _var), nextVal.i);
};
var B_next = (prev, initial, schema, expected = prev.e) => {
return {
b: U,
p: U,
v: _notVar,
i: initial,
s: schema,
io: U,
e: expected,
prev,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: true,
path: prev.path,
g: prev.g,
o: U,
};
};
var B_refine = (val, schema = val.s, checks, expected = val.e) => {
const shouldLink = val.v !== _var;
const nextVal = {
b: U,
p: U,
v: shouldLink ? _linkVar : _var,
i: val.i,
s: schema,
io: U,
e: expected,
prev: val,
f: val.f,
d: val.d,
fv: U,
cp: "",
hd: "",
fz: U,
vc: checks,
u: U,
t: val.t,
path: val.path,
g: val.g,
o: U,
};
if (shouldLink) B_linkVar(val, nextVal);
return nextVal;
};
var B_pushCheck = (val, check) => {
(val.vc ?? (val.vc = [])).push(check);
};
var B_markOutput = (val, valInput) => {
let outC;
const ir = valInput.e.inputRefiner;
if (ir) {
const c = ir(valInput);
if (c.length) (valInput.vc ?? (valInput.vc = [])).push(...c);
}
const rf = val.e.refiner;
if (rf) {
const c = rf(val);
if (c.length) outC = c;
}
if (outC && val.f & 1) {
const v = val.v();
val.i = `${v}.then(${v}=>{${B_merge(B_refine(B_scope(val), U, outC))}return ${v}})`;
val.v = _notVar;
} else if (outC) val = B_refine(val, U, outC);
val.io = true;
return val;
};
var B_hoistChildChecks = (parent, child, key) => {
const checks = child.vc;
if (checks) {
const accessor = inlinedProperty("", key, parent.s.type === arrayTag);
for (let i = 0; i < checks.length; i++) {
const check = checks[i];
B_pushCheck(parent, {
c: (v) => check.c(v + accessor),
f: check.f,
});
}
child.vc = U;
}
};
var B_dynamicScope = (from, locationVar) => {
const schemaAdditionalItems = from.s.additionalItems;
const expectedAdditionalItems = from.e.additionalItems;
return {
b: U,
p: from,
v: _notVarBeforeValidation,
i: `${from.v()}[${locationVar}]`,
s:
schemaAdditionalItems !== U && typeof schemaAdditionalItems !== "string"
? schemaAdditionalItems
: unknown,
io: U,
e:
expectedAdditionalItems !== U && typeof expectedAdditionalItems !== "string"
? expectedAdditionalItems
: unknown,
prev: U,
f: from.f,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathEmpty,
g: from.g,
o: U,
};
};
var B_nextConst = (from, schema, expected) =>
B_next(from, B_inlineConst(from, schema), schema, expected);
var B_nextVar = (input, schema = input.e, expected = schema) => {
const output = B_next(input, B_varWithoutAllocation(input.g), schema, expected);
output.v = _var;
return output;
};
var B_nextVarOutput = (input, initial, schema, expected = schema) => {
const output = B_next(input, initial, schema, expected);
output.v = _var;
output.io = true;
return output;
};
var B_asyncVal = (from, initial) => {
const v = B_next(from, initial, from.s);
v.f = 1;
return v;
};
var B_addObjectField = (objectVal, location, val) => {
if (objectVal.s.type === arrayTag) objectVal.s.items.push(val.s);
else {
if (!val.o) objectVal.s.required.push(location);
objectVal.s.properties[location] = val.s;
}
if (val.f & 1) val.v();
objectVal.cp += B_merge(val);
objectVal.d[location] = val;
};
var B_addKey = (objVal, key, value) => `${objVal.v()}[${key}]=${value.i}`;
var B_scope = (val) => {
const shouldLink = val.v !== _var;
const nextVal = {
b: val,
p: U,
v: shouldLink ? _linkVar : _var,
i: val.i,
s: val.s,
io: val.io,
e: val.e,
prev: U,
f: 0,
d: val.d,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: false,
t: false,
path: val.path,
g: val.g,
o: U,
};
if (shouldLink) B_linkVar(val, nextVal);
return nextVal;
};
var B_neverSlot = (input) =>
B_invalidOperation(
input,
`Nothing decodes ${/* @__PURE__ */ inputExpression(input.e)} -> ${/* @__PURE__ */ inputExpression(input.e.to)}. It is marked with S.never`,
);
var B_invalidOperation = (val, description) =>
B_throw({
code: "invalid_operation",
reason: description,
path: val.path,
});
var B_mergeWithCatch = (val, catchFn, appendSafe, pureSince) => {
const valCode = B_merge(val);
const pure = pureSince !== U && val.g.t === pureSince;
if ((valCode === "" || pure) && !(val.f & 1))
return appendSafe ? valCode + appendSafe() : pure ? "" : valCode;
const errorVar = B_varWithoutAllocation(val.g);
B_markThrow(val);
const catchCode = `${catchFn(errorVar)};throw ${errorVar}`;
if (val.f & 1) val.i = `${val.i}.catch(${errorVar}=>{${catchCode}})`;
return `try{${valCode}${appendSafe ? appendSafe() : ""}}catch(${errorVar}){${catchCode}}`;
};
var B_mergeWithPathPrepend = (val, parent, locationVar, appendSafe, pureSince) =>
!val.path.length && locationVar === U
? B_merge(val)
: B_mergeWithCatch(
val,
(errorVar) => {
let segments = "";
for (let idx = 0; idx < parent.path.length; idx++) {
const segment = parent.path[idx];
segments += `${typeof segment === "string" ? inlinedValueFromString(segment) : segment},`;
}
if (locationVar !== U) segments += `${locationVar},`;
return `${errorVar}.path=[${segments}...${errorVar}.path]`;
},
appendSafe,
pureSince,
);
var noopOperation = (i) => i;
noopOperation["embedded"] = immutableEmptyArray;
var int32FormatValidation = (inputVar) =>
`${inputVar}<=2147483647&&${inputVar}>=-2147483648&&${inputVar}%1==0`;
var integerFormatValidation = (inputVar) => `${inputVar}%1==0`;
var typeofCondCache = {};
var typeofCond = (tag) =>
typeofCondCache[tag] || (typeofCondCache[tag] = (inputVar) => `typeof ${inputVar}==="${tag}"`);
var nanCond = (inputVar) => `Number.isNaN(${inputVar})`;
var isArrayCond = (inputVar) => `Array.isArray(${inputVar})`;
var objectTagCond = (inputVar) =>
`${typeofCond(objectTag)(inputVar)}&&${inputVar}&&!${isArrayCond(inputVar)}`;
var numberTagCond = (inputVar, allowNaN) => {
const t = typeofCond(numberTag)(inputVar);
return allowNaN ? t : `${t}&&${inputVar}==${inputVar}`;
};
var instanceofCond = (b, class_, inputVar) => `${inputVar} instanceof ${B_embed(b, class_)}`;
var typeofCheckCache = {};
var typeofCheck = (tag) =>
typeofCheckCache[tag] ||
(typeofCheckCache[tag] = {
c: typeofCond(tag),
f: failInvalidType,
});
var B_typeDecode = (input, tag, inputTagFlag) =>
inputTagFlag & 1
? B_refine(input, input.e, [typeofCheck(tag)])
: inputTagFlag & tagFlags[tag]
? input
: B_unsupportedDecode(input, input.s, input.e);
var numberDecoder = (input) => {
const inputTagFlag = tagFlags[input.s.type];
const expectedFormat = input.e.format;
if (inputTagFlag & 1) {
if (expectedFormat === "int32")
return B_refine(input, input.e, [
typeofCheck(numberTag),
{
c: int32FormatValidation,
f: failInvalidType,
},
]);
if (expectedFormat === "integer")
return B_refine(input, input.e, [
typeofCheck(numberTag),
{
c: integerFormatValidation,
f: failInvalidType,
},
]);
return B_refine(input, input.e, [
{
c: (v) => numberTagCond(v, !!(input.g.o & 2)),
f: failInvalidType,
},
]);
} else if (inputTagFlag & 2) {
const output = B_nextVar(input);
const inputVar = input.v();
output.cp = `let ${output.i}=+${inputVar};`;
output.vc = [
{
c: (_inputVar) =>
`${expectedFormat === "int32" ? int32FormatValidation(output.i) : expectedFormat === "integer" ? integerFormatValidation(output.i) : `${output.i}==${output.i}`}&&(${output.i}||${inputVar}.trim())`,
f: failInvalidType,
},
];
return output;
} else if (
inputTagFlag & 2048 &&
expectedFormat !== "int32" &&
expectedFormat !== "integer" &&
input.g.o & 2
)
return B_refine(input, input.e);
else if (inputTagFlag & 4) {
if (input.s.format !== expectedFormat && expectedFormat === "int32")
return B_refine(input, input.e, [
input.s.format === U
? {
c: int32FormatValidation,
f: failInvalidType,
}
: {
c: (inputVar) => `${inputVar}<=2147483647&&${inputVar}>=-2147483648`,
f: failInvalidType,
},
]);
if (expectedFormat === "integer" && input.s.format === U)
return B_refine(input, input.e, [
{
c: integerFormatValidation,
f: failInvalidType,
},
]);
}
return B_typeDecode(input, numberTag, inputTagFlag);
};
var float = initSchema(numberTag, numberDecoder);
var inputToString = (input, schema = string) => B_next(input, `""+${input.i}`, schema);
var stringDecoderFn = (input) => {
const inputTagFlag = tagFlags[input.s.type];
if (inputTagFlag & 3132 && isLiteral(input.s)) {
const const_ = "" + input.s.const;
const schema = baseSchema(stringTag, false, input.s.decoder);
schema.const = const_;
return B_next(input, `"${const_}"`, schema);
}
if (inputTagFlag & 1036) return inputToString(input, input.e);
return B_typeDecode(input, stringTag, inputTagFlag);
};
var string = initSchema(stringTag, stringDecoderFn);
var literalDecoder = (input) => {
const expectedSchema = input.e;
if (expectedSchema.noValidation && !input.u) return B_nextConst(input, expectedSchema);
else if (isLiteral(input.s)) {
if (input.s.const === expectedSchema.const) return input;
else return B_nextConst(input, expectedSchema);
} else {
const schemaTagFlag = tagFlags[expectedSchema.type];
if (tagFlags[input.s.type] & 2 && schemaTagFlag & 3132) {
const stringConstSchema = baseSchema(stringTag, false, literalDecoder);
stringConstSchema.const = "" + expectedSchema.const;
const stringConstVal = B_nextConst(input, stringConstSchema, stringConstSchema);
stringConstVal.vc = [
{
c: (inputVar) => `${inputVar}==="${stringConstSchema.const}"`,
f: failInvalidType,
},
];
return B_nextConst(stringConstVal, expectedSchema, expectedSchema);
} else if (schemaTagFlag & 2048)
return B_refine(input, expectedSchema, [
{
c: nanCond,
f: failInvalidType,
},
]);
else
return B_refine(input, expectedSchema, [
{
c: (inputVar) => `${inputVar}===${B_inlineConst(input, expectedSchema)}`,
f: failInvalidType,
},
]);
}
};
var unit = initSchema(undefinedTag, literalDecoder, (s2) => {
s2.const = U;
});
var nullLiteral = initSchema(nullTag, literalDecoder, (s2) => {
s2.const = null;
});
var nan = initSchema(nanTag, literalDecoder, (s2) => {
s2.const = NaN;
});
var Literal_parse = (value) => {
if (value === null) return nullLiteral;
else {
const tag = typeof value;
if (tag === undefinedTag) return unit;
else if (tag === numberTag && Number.isNaN(value)) return nan;
else if (tag === objectTag) {
const s2 = baseSchema(instanceTag, true, literalDecoder);
s2.class = value["constructor"];
s2.const = value;
return s2;
} else {
const s2 = baseSchema(tag, true, literalDecoder);
s2.const = value;
return s2;
}
}
};
var parse = (input) => {
let result = input;
let appliedEncoderRef = U;
let loopCount = 0;
while (!result.io || result.e.to) {
const appliedEncoder = appliedEncoderRef;
appliedEncoderRef = U;
const loopInput = result;
if (++loopCount > 50) panic("Loop count exceeded 50");
const defs = loopInput.e["$defs"];
if (defs) loopInput.g.d ? Object.assign(loopInput.g.d, defs) : (loopInput.g.d = defs);
if (loopInput.f & 1) {
const operationInputVar = loopInput.v();
const operationInput = B_scope(loopInput);
const operationOutput = parse(operationInput);
const operationCode = B_merge(operationOutput);
result =
operationInput.i !== operationOutput.i || operationCode !== ""
? B_next(
loopInput,
`${operationInputVar}.then(${operationInputVar}=>{${operationCode}return ${operationOutput.i}})`,
operationOutput.s,
operationOutput.e,
)
: B_refine(loopInput, operationOutput.s, U, operationOutput.e);
result.f |= 1;
result.io = true;
} else if (loopInput.io) {
const to2 = loopInput.e.to;
result = loopInput.e.parser ? loopInput.e.parser(loopInput) : B_refine(result, U, U, to2);
} else {
const maybeEncoder = loopInput.s.encoder;
if (
maybeEncoder &&
maybeEncoder !== appliedEncoder &&
loopInput.s !== loopInput.e &&
loopInput.e.type !== unknownTag &&
!(loopInput.e.noValidation && (loopInput.e.isJson || loopInput.e.type === undefinedTag))
)
result = maybeEncoder(loopInput, loopInput.e);
if (loopInput !== result) appliedEncoderRef = maybeEncoder;
else {
result = loopInput.e.decoder(loopInput);
if (!result.io) result = B_markOutput(result, result);
}
}
}
return result;
};
var parseDynamic = (input) => {
try {
return parse(input);
} catch (exn) {
const error = getOrRethrow(exn);
error.path = pathConcat(
input.p ? input.p.path : pathEmpty,
pathConcat( pathConcat(input.path, pathDynamic), error.path),
);
throw error;
}
};
var throwTail = (input, code, out, isAsync, flag, hasDefs) => {
if (flag & 1024) {
const errorOf = B_errorOf(input);
const issues = B_embedPure(input, (e2) => {
const error = errorOf(e2);
return {
issues: [
{
message: error.reason,
path: error.path.length ? error.path : U,
},
],
};
});
const v = isAsync ? B_varWithoutAllocation(input.g) : "";
const body = isAsync
? `${code}return ${out}.then(${v}=>({value:${v}}),${issues})`
: `${code}return {value:${out}}`;
if (!input.g.t) return body;
const e = B_varWithoutAllocation(input.g);
return `try{${body}}catch(${e}){return ${isAsync ? `Promise.resolve(${issues}(${e}))` : `${issues}(${e})`}}`;
}
return code === "" && out === operationArgVar && !(flag & 1)
? U
: `${code}return ${flag & 1 && !isAsync && !hasDefs ? `Promise.resolve(${out})` : out}`;
};
var emitTail = throwTail;
var compileDecoder = (schema, expected, flag, defs, node) => {
const input = B_operationArg(isLiteral(schema) ? unknown : schema, expected, flag, defs);
const output = parse(input);
const code = B_merge(output);
const isAsync = !!(output.f & 1);
if (node) {
node.y = isAsync;
node.t = output.t === true;
}
const body = emitTail(input, code, output.i, isAsync, flag, !!defs);
if (!body) return noopOperation;
const fn = new Function("e", "s", `return ${operationArgVar}=>{${body}}`)(input.g.e, s);
fn.embedded = input.g.e;
return fn;
};
var getOutputSchema = (schema) => {
while (schema.to) schema = schema.to;
return schema;
};
var reverseSwap = (mut, a, b) => {
const previous = mut[a];
mut[b] === U ? delete mut[a] : (mut[a] = mut[b]);
previous === U ? delete mut[b] : (mut[b] = previous);
};
var reverseDict = (dict2) => {
const reversed = Object.create(null);
for (const key in dict2) reversed[key] = reverse(dict2[key]);
return reversed;
};
Object.defineProperty(schemaPrototype, reversedKey, {
get() {
const schema = this;
let reversedHead = U;
let current = schema;
while (current) {
const mut = copySchema(current);
const next = mut.to;
reversedHead ? (mut.to = reversedHead) : delete mut.to;
const record = mut;
reverseSwap(record, "parser", "serializer");
reverseSwap(record, "refiner", "inputRefiner");
next && next.opens !== U ? (mut.opens = !next.opens) : delete mut.opens;
delete record["default"];
delete record["examples"];
if (mut.items) mut.items = mut.items.map(reverse);
if (mut.properties) mut.properties = reverseDict(mut.properties);
if (typeof mut.additionalItems === objectTag)
mut.additionalItems = reverse(mut.additionalItems);
if (mut.anyOf) {
const anyOf = mut.anyOf;
const has = {};
const newAnyOf = [];
for (let idx = 0; idx < anyOf.length; idx++) {
const s2 = anyOf[idx];
const reversed = reverse(s2);
newAnyOf.push(reversed);
setHas(has, reversed.type);
}
mut.has = has;
mut.anyOf = newAnyOf;
}
if (mut["$defs"]) mut["$defs"] = reverseDict(mut["$defs"]);
reversedHead = mut;
current = next;
}
const r = reversedHead;
valueOptions[valKey] = r;
Object.defineProperty(schema, reversedKey, valueOptions);
valueOptions[valKey] = schema;
Object.defineProperty(r, reversedKey, valueOptions);
return r;
},
});
var reverse = (schema) => schema.r;
var memoKey = "c";
var addOpNode = (schema, a, f, v) => {
const created = {
a,
f,
v,
n: schema[memoKey],
};
configurableValueOptions[valKey] = created;
Object.defineProperty(schema, memoKey, configurableValueOptions);
return created;
};
var compileChain = (cacheTarget, args, flag) => {
let schema = args[args.length - 1];
for (let i = args.length - 2; i >= 0; i--) {
const to2 = schema;
schema = updateOutput(args[i], (mut) => {
mut.to = to2;
if (mut.content !== U && mut.opens === U) mut.opens = true;
});
}
const f = compileDecoder(flag & 8 ? unknown : schema, schema, flag, U);
addOpNode(cacheTarget, args, flag, f);
return f;
};
var getOp = (opFlag, n, a0, a1, a2, a3) => {
const flag = opFlag | globalConfig.f;
let cacheTarget = a0;
let seq2 = a0.seq;
if (n > 1) {
if (a1.seq > seq2) ((seq2 = a1.seq), (cacheTarget = a1));
if (n > 2) {
if (a2.seq > seq2) ((seq2 = a2.seq), (cacheTarget = a2));
if (n > 3 && a3.seq > seq2) cacheTarget = a3;
}
}
let node = cacheTarget[memoKey];
while (node) {
const a = node.a;
if (
node.f === flag &&
a.length === n &&
a[0] === a0 &&
(n < 2 || a[1] === a1) &&
(n < 3 || a[2] === a2) &&
(n < 4 || a[3] === a3)
)
return node.v;
node = node.n;
}
return compileChain(cacheTarget, [a0, a1, a2, a3].slice(0, n), flag);
};
var nestedLoc = "BS_PRIVATE_NESTED_SOME_NONE";
var never_ = initSchema(neverTag, (input) => {
const output = B_refine(input, never_, U, never_);
output.cp = B_embedInvalidInput(input) + ";";
return output;
});
var instanceDecoder = (input) => {
const inputTagFlag = tagFlags[input.s.type];
return inputTagFlag & 1
? B_refine(input, input.e, [
{
c: (v) => instanceofCond(input, input.e.class, v),
f: failInvalidType,
},
])
: inputTagFlag & 8192 && input.s.class === input.e.class
? input
: B_unsupportedDecode(input, input.s, input.e);
};
var typeCheckCond = (input, schema, inputVar) => {
const tagFlag = tagFlags[schema.type];
if (tagFlag & 64) return objectTagCond(inputVar);
if (tagFlag & 128) return isArrayCond(inputVar);
if (tagFlag & 8192) return instanceofCond(input, schema.class, inputVar);
if (tagFlag & 4) return numberTagCond(inputVar, !!(input.g.o & 2));
if (tagFlag & 2048) return nanCond(inputVar);
if (tagFlag & 48) return `${inputVar}===${B_inlineConst(input, schema)}`;
if (tagFlag & 17418)
return schema.format === "env"
? `(typeof ${inputVar}==="string"||${inputVar}===void 0)`
: typeofCond(schema.type)(inputVar);
return "";
};
var isItemSchema = (x) => x !== U && typeof x !== "string";
var B_unrecognizedKeys = (input, keys, keyVar, decl) => {
const fail = B_failWithArg(
input,
(key) => ({
code: "unrecognized_key",
path: input.path,
reason: `Unrecognized key ${stringify(key)}`,
key,
}),
keyVar,
);
let cond = "";
for (let idx = 0; idx < keys.length; idx++) {
if (idx) cond += "&&";
cond += `${keyVar}!==${inlinedValueFromString(keys[idx])}`;
}
return `for(${decl}${keyVar} in ${input.v()})` + (cond ? `if(${cond})` : "") + fail + ";";
};
var B_fused = (input, expectedSchema, item) => {
const to2 = expectedSchema.to;
return to2 !== U && to2.fz !== U ? to2.fz(input, expectedSchema, item) : U;
};
var B_narrowJsonSourcedJsonString = (itemInput) => {
if (itemInput.s.isJson && itemInput.e.format === "json") itemInput.s = unknown;
};
var B_makeContainerVal = (prev, schema) => ({
b: U,
p: U,
v: _notVar,
i: "",
s: schema,
io: U,
e: prev.e,
prev,
f: 0,
d: Object.create(null),
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: true,
path: prev.path,
g: prev.g,
o: U,
});
var makeObjectVal = (prev) =>
B_makeContainerVal(prev, {
type: objectTag,
required: [],
properties: Object.create(null),
additionalItems: "strict",
decoder: objectDecoder,
});
var makeArrayVal = (prev) =>
B_makeContainerVal(prev, {
type: arrayTag,
items: [],
additionalItems: "strict",
decoder: arrayDecoder,
});
var completeObjectVal = (objectVal) => {
const isArray = objectVal.s.type === arrayTag;
let inline = "";
let promiseAllContent = "";
let optionalSettingCode = U;
const keys = Object.keys(objectVal.d);
for (let idx = 0; idx < keys.length; idx++) {
const key = keys[idx];
const val = objectVal.d[key];
if (val.f & 1) promiseAllContent += val.i + ",";
if (val.o) {
const existingFn = optionalSettingCode;
optionalSettingCode = (objectVar) => {
return (
(existingFn === U ? "" : existingFn(objectVar)) +
(key === "__proto__"
? `if(${val.v()}!==void 0){${objectVar}={...${objectVar},["__proto__"]:${val.i}}}`
: `if(${val.v()}!==void 0){${inlinedProperty(objectVar, key, isArray)}=${val.i}}`)
);
};
} else inline = inline + (isArray ? `${val.i}` : `${inlinedObjectKey(key)}:${val.i}`) + ",";
}
objectVal.i = isArray ? "[" + inline.slice(0, -1) + "]" : "{" + inline.slice(0, -1) + "}";
if (promiseAllContent) {
promiseAllContent = promiseAllContent.slice(0, -1);
const operationInput = B_scope(objectVal);
operationInput.io = true;
const operationOutput = parse(operationInput);
let operationCode = B_merge(operationOutput);
let result = operationOutput.i;
if (optionalSettingCode !== U) {
const objectVar = B_varWithoutAllocation(objectVal.g);
operationCode =
operationCode + `let ${objectVar}=${result};` + optionalSettingCode(objectVar);
result = objectVar;
}
if (operationCode === "" && promiseAllContent === result) objectVal.i = result;
else
objectVal.i = `Promise.all([${promiseAllContent}]).then(([${promiseAllContent}])=>{${operationCode}return ${result}})`;
objectVal.f |= 1;
objectVal.s = operationOutput.s;
objectVal.e = operationOutput.e;
objectVal.io = true;
return objectVal;
} else if (optionalSettingCode === U) return objectVal;
else {
const code = optionalSettingCode(objectVal.v());
const output = B_refine(objectVal);
output.cp = output.cp + code;
return output;
}
};
var arrayFactory = (item) => {
const mut = baseSchema(arrayTag, !!item.sr, arrayDecoder);
mut.additionalItems = item;
mut.items = immutableEmptyArray;
return mut;
};
var array = (item) =>
arrayFactory( definitionToSchema(item));
var arrayDecoder = (unknownInput) => {
const isUnion = unknownInput.u;
const expectedSchema = unknownInput.e;
const unknownInputTagFlag = tagFlags[unknownInput.s.type];
const expectedItems = expectedSchema.items;
const expectedLength = expectedItems.length;
let input;
if (unknownInputTagFlag & 129) {
const isArrayInput = unknownInputTagFlag & 128;
let schema;
if (!isArrayInput) schema = arrayFactory(unknown);
else schema = unknownInput.s;
const checks = [];
if (!isArrayInput)
checks.push({
c: isArrayCond,
f: failInvalidType,
});
const schemaAdditionalItems = schema.additionalItems;
if (!(isItemSchema(schemaAdditionalItems) ? false : schema.items.length === expectedLength)) {
const expectedAdditionalItems2 = expectedSchema.additionalItems;
if (expectedAdditionalItems2 === "strict")
checks.push({
c: (inputVar) => `${inputVar}.length===${expectedLength}`,
f: failInvalidType,
});
else if (expectedAdditionalItems2 === "strip")
checks.push({
c: (inputVar) => `${inputVar}.length>=${expectedLength}`,
f: failInvalidType,
});
}
input = B_refine(unknownInput, schema, checks.length ? checks : U);
} else input = B_unsupportedDecode(unknownInput, unknownInput.s, expectedSchema);
let output;
const expectedAdditionalItems = expectedSchema.additionalItems;
if (isItemSchema(expectedAdditionalItems)) {
const itemSchema = expectedAdditionalItems;
if (itemSchema === unknown) output = input;
else {
if (expectedLength === 0) {
const fused = B_fused(input, expectedSchema, itemSchema);
if (fused !== U) return B_markOutput(B_refine(input, fused), input);
}
const inputVar = input.v();
const iteratorVar = B_varWithoutAllocation(input.g);
const raiseCountBefore = input.g.t;
const itemInput = B_dynamicScope(input, iteratorVar);
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parseDynamic(itemInput);
const hasTransform = itemOutput.t;
const output2 = hasTransform
? B_next(input, `new Array(${inputVar}.length)`, arrayFactory(itemOutput.s))
: B_refine(input, expectedSchema);
const itemCode = B_mergeWithPathPrepend(
itemOutput,
input,
iteratorVar,
hasTransform ? () => B_addKey(output2, iteratorVar, itemOutput) : U,
hasTransform ? U : raiseCountBefore,
);
if (hasTransform || itemCode !== "")
output2.cp =
output2.cp +
`for(let ${iteratorVar}=${expectedLength};${iteratorVar}<${inputVar}.length;++${iteratorVar}){${itemCode}}`;
if (itemOutput.f & 1) output = B_asyncVal(output2, `Promise.all(${output2.i})`);
else output = output2;
}
} else {
const objectVal = makeArrayVal(input);
const fused = B_fused(input, expectedSchema);
const ai = expectedSchema.additionalItems;
let shouldRecreateInput =
fused === U &&
ai !== "strict" &&
(ai !== "strip" ||
isItemSchema(input.s.additionalItems) ||
input.s.items.length !== expectedLength);
for (let idx = 0; idx < expectedLength; idx++) {
const schema = expectedItems[idx];
const key = String(idx);
const itemInput = valGet(input, key);
itemInput.e = schema;
itemInput.io = false;
itemInput.u = isUnion;
if (fused !== U && !(isUnion && isLiteral(schema))) {
B_addObjectField(objectVal, key, itemInput);
continue;
}
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parse(itemInput);
if (isUnion && isLiteral(schema)) B_hoistChildChecks(input, itemOutput, key);
B_addObjectField(objectVal, key, itemOutput);
if (!shouldRecreateInput) shouldRecreateInput = itemOutput.t;
}
if (shouldRecreateInput) output = completeObjectVal(objectVal);
else {
const o = B_refine(input, fused || expectedSchema);
o.cp = objectVal.cp;
o.d = objectVal.d;
output = o;
}
}
return B_markOutput(output, input);
};
var objectTypeCheck = {
c: objectTagCond,
f: failInvalidType,
};
var objectDecoder = (unknownInput) => {
const isUnion = unknownInput.u;
const expectedSchema = unknownInput.e;
const unknownInputTagFlag = tagFlags[unknownInput.s.type];
let input;
if (unknownInputTagFlag & 65) {
const isObjectInput = unknownInputTagFlag & 64;
let schema;
if (!isObjectInput) {
const mut = baseSchema(objectTag, false, objectDecoder);
mut.properties = immutableEmptyObject;
mut.additionalItems = unknown;
schema = mut;
} else schema = unknownInput.s;
input = isObjectInput
? B_refine(unknownInput, schema)
: B_refine(unknownInput, schema, [objectTypeCheck]);
} else input = B_unsupportedDecode(unknownInput, unknownInput.s, expectedSchema);
const expectedAdditionalItems = expectedSchema.additionalItems;
const dictItem = isItemSchema(expectedAdditionalItems) ? expectedAdditionalItems : U;
const inputAdditionalItems = input.s.additionalItems;
const sourceIsDict = isItemSchema(inputAdditionalItems);
let output;
if (dictItem !== U && dictItem === unknown) output = input;
else if (dictItem !== U && sourceIsDict) {
const fused = B_fused(input, expectedSchema, dictItem);
if (fused !== U) return B_markOutput(B_refine(input, fused), input);
const inputVar = input.v();
const keyVar = B_varWithoutAllocation(input.g);
const raiseCountBefore = input.g.t;
const itemInput = B_dynamicScope(input, keyVar);
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parseDynamic(itemInput);
const hasTransform = itemOutput.t;
const output2 = hasTransform
? B_next(input, "{}", dictFactory(itemOutput.s))
: B_refine(input, expectedSchema);
const itemCode = B_mergeWithPathPrepend(
itemOutput,
input,
keyVar,
hasTransform ? () => B_addKey(output2, keyVar, itemOutput) : U,
hasTransform ? U : raiseCountBefore,
);
if (hasTransform || itemCode !== "")
output2.cp = output2.cp + `for(let ${keyVar} in ${inputVar}){${itemCode}}`;
if (itemOutput.f & 1) {
const resolveVar = B_varWithoutAllocation(output2.g);
const rejectVar = B_varWithoutAllocation(output2.g);
const asyncParseResultVar = B_varWithoutAllocation(output2.g);
const counterVar = B_varWithoutAllocation(output2.g);
const outputVar = output2.v();
output = B_asyncVal(
output2,
`new Promise((${resolveVar},${rejectVar})=>{let ${counterVar}=Object.keys(${outputVar}).length;if(!${counterVar}){${resolveVar}(${outputVar})}for(let ${keyVar} in ${outputVar}){${outputVar}[${keyVar}].then(${asyncParseResultVar}=>{${outputVar}[${keyVar}]=${asyncParseResultVar};if(${counterVar}--===1){${resolveVar}(${outputVar})}},${rejectVar})}})`,
);
} else output = output2;
} else if (dictItem !== U) {
const itemSchema = dictItem;
const objectVal = makeObjectVal(input);
const keys = Object.keys(input.s.properties);
for (let idx = 0; idx < keys.length; idx++) {
const key = keys[idx];
const itemInput = valGet(input, key);
const source = itemInput.s;
const absent =
source.type === anyOfTag &&
source.has[undefinedTag] &&
!(tagFlags[itemSchema.type] & 817) &&
itemSchema.format !== "json";
if (absent) {
const target = copySchema(source);
target.anyOf = source.anyOf.map((variant) =>
variant.type === undefinedTag
? variant
: updateOutput(variant, (mut) => {
mut.to = itemSchema;
}),
);
target.perVariant = true;
itemInput.e = target;
} else itemInput.e = itemSchema;
itemInput.io = false;
itemInput.u = isUnion;
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parse(itemInput);
if (absent) itemOutput.o = true;
B_addObjectField(objectVal, key, itemOutput);
}
output = completeObjectVal(objectVal);
} else {
const properties = expectedSchema.properties;
const keys = Object.keys(properties);
const keysCount = keys.length;
const objectVal = makeObjectVal(input);
const ai = expectedSchema.additionalItems;
const fused = B_fused(input, expectedSchema);
let shouldRecreateInput =
fused === U &&
ai !== "strict" &&
(ai !== "strip" || sourceIsDict || Object.keys(input.s.properties).length !== keysCount);
const isJsonParent = isItemSchema(inputAdditionalItems) && inputAdditionalItems.isJson;
for (let idx = 0; idx < keysCount; idx++) {
const key = keys[idx];
const schema = properties[key];
const itemInput = valGet(input, key);
itemInput.e = schema;
itemInput.io = false;
itemInput.u = isUnion;
if (isJsonParent && schema.type === anyOfTag && schema.has[undefinedTag])
itemInput.i = `(${itemInput.i}??null)`;
if (fused !== U && !(isUnion && isLiteral(schema))) {
B_addObjectField(objectVal, key, itemInput);
continue;
}
B_narrowJsonSourcedJsonString(itemInput);
const itemOutput = parse(itemInput);
if (isUnion && isLiteral(schema)) B_hoistChildChecks(input, itemOutput, key);
B_addObjectField(objectVal, key, itemOutput);
if (!shouldRecreateInput) shouldRecreateInput = itemOutput.t;
}
if (ai === "strict" && isItemSchema(inputAdditionalItems) && fused === U) {
const keyVar = B_varWithoutAllocation(objectVal.g);
B_hoistDecl(input, keyVar);
objectVal.cp += B_unrecognizedKeys(input, keys, keyVar, "");
}
if (shouldRecreateInput) output = completeObjectVal(objectVal);
else {
const o = B_refine(input, fused || expectedSchema);
o.cp = objectVal.cp;
o.d = objectVal.d;
output = o;
}
}
return B_markOutput(output, input);
};
var dictFactory = (item) => {
const mut = baseSchema(objectTag, !!item.sr, objectDecoder);
mut.properties = immutableEmptyObject;
mut.additionalItems = item;
return mut;
};
var definitionToSchema = (definition) =>
isSchemaObject(definition)
? definition
: traverseDefinition(definition, (node) => (isSchemaObject(node) ? node : U));
var traverseDefinition = (definition, onNode) => {
if (typeof definition === objectTag && definition !== null) {
const s2 = onNode(definition);
if (s2 !== U) return s2;
else if (Array.isArray(definition)) {
const node = definition;
for (let idx = 0; idx < node.length; idx++) node[idx] = traverseDefinition(node[idx], onNode);
const items = node;
const mut = baseSchema(arrayTag, false, arrayDecoder);
mut.items = items;
mut.additionalItems = "strict";
return mut;
} else {
const proto = Object.getPrototypeOf(definition);
if (proto !== null && proto !== Object.prototype) {
const mut = baseSchema(instanceTag, true, literalDecoder);
mut.class = definition["constructor"];
mut.const = definition;
return mut;
} else {
const node = definition;
const fieldNames = Object.keys(node);
const length2 = fieldNames.length;
for (let idx = 0; idx < length2; idx++) {
const location = fieldNames[idx];
node[location] = traverseDefinition(node[location], onNode);
}
const mut = baseSchema(objectTag, false, objectDecoder);
mut.required = fieldNames;
mut.properties = node;
mut.additionalItems = globalConfig.a;
return mut;
}
}
} else return Literal_parse(definition);
};
var missingKeyEncoder = (input, target) => {
const item = input.s.anyOf[0];
const v = input.v();
const presentIn = B_scope(input);
presentIn.io = false;
presentIn.s = item;
presentIn.e = target;
presentIn.u = true;
const presentOut = parse(presentIn);
const presentCode = B_merge(presentOut);
const presentAssign = presentOut.i === v ? "" : `${v}=${presentOut.i};`;
const absentCode2 = isOptional(target) ? "" : B_embedInvalidInput(input, target);
const output = B_nextVarOutput(input, v, getOutputSchema(target), target);
const presentBody = presentCode + presentAssign;
output.cp =
presentBody === ""
? absentCode2 === ""
? ""
: `${v}!==void 0||${absentCode2};`
: absentCode2 === ""
? `if(${v}!==void 0){${presentBody}}`
: `if(${v}!==void 0){${presentBody}}else{${absentCode2}}`;
return output;
};
var wrapDictMissingKeyLight = (s2) => {
const mut = baseSchema(anyOfTag, false, noopDecoder);
mut.anyOf = [s2, unit];
mut.has = { [undefinedTag]: true };
setHas(mut.has, s2.type);
mut.encoder = missingKeyEncoder;
mut.perVariant = true;
return mut;
};
var valGet = (parent, location) => {
const vals = parent.d ?? (parent.d = Object.create(null));
const existing = vals[location];
if (existing !== U) return B_scope(existing);
else {
let locationSchema;
if (parent.s.type === objectTag) locationSchema = parent.s.properties[location];
else locationSchema = parent.s.items[Number(location)];
let schema;
if (locationSchema !== U) schema = locationSchema;
else {
const additionalItems = parent.s.additionalItems;
if (isItemSchema(additionalItems)) {
const s2 = additionalItems;
if (
parent.s.type === objectTag &&
s2.type !== unknownTag &&
!(tagFlags[s2.type] & 512) &&
!isOptional(s2)
)
schema = wrapDictMissingKeyLight(s2);
else schema = s2;
} else schema = B_unsupportedDecode(parent, parent.s, parent.e);
}
const accessor = inlinedProperty("", location, parent.s.type === arrayTag);
const item = {
b: U,
p: parent,
v: _notVarAtParent,
i: isLiteral(schema)
? B_inlineConst(parent, schema)
: parent.s.type === objectTag && location in Object.prototype
? `(Object.hasOwn(${parent.v()},${inlinedValueFromString(location)})?${parent.v()}${accessor}:void 0)`
: `${parent.v()}${accessor}`,
s: schema,
io: U,
e: schema,
prev: U,
f: 0,
d: U,
fv: U,
cp: "",
hd: "",
fz: U,
vc: U,
u: U,
t: U,
path: pathConcat(parent.path, [location]),
g: parent.g,
o: U,
};
vals[location] = item;
return item;
}
};
var unionRuntimeSame = (a, b) => a.type === b.type && a.class === b.class;
var unionSameType = (a, b) =>
a === b || (unionRuntimeSame(a, b) && !(tagFlags[a.type] & 768) && a.format === b.format);
var unionLiteralEqual = (a, b) => a === b || (a !== a && b !== b);
var unionOutput = (schema) => {
let output = schema;
while (output.type !== neverTag && output.to !== U) {
if (output.parser === B_neverSlot) return never_;
output = output.to;
}
return output;
};
var unionNeverLink = (schema) => {
for (let node = schema; node !== U && node.type !== neverTag; node = node.to)
if (node.parser === B_neverSlot) return true;
return false;
};
var unionIsTransparent = (schema) => {
if (schema.type !== anyOfTag) return false;
let fields = 0;
for (const _key in schema) fields++;
return fields === 6;
};
var unionTraits = (schema) => {
const tag = tagFlags[schema.type];
let traits = 0;
if (tag & 4864 || schema.parser !== U) return 15;
if (schema.refiner !== U || schema.inputRefiner !== U) traits |= 3;
else if (tag & 8384) traits |= 2;
if (schema.format !== U || isLiteral(schema)) traits |= 1;
const to2 = schema.to;
if (to2 !== U) {
if (to2 === schema || to2.parser !== U || tagFlags[to2.type] & 4864) traits |= 15;
else if (
!(
to2.noValidation === true ||
tagFlags[to2.type] & 1 ||
unionRuntimeSame(schema, to2) ||
(to2.type === anyOfTag && unionMask(to2, 1, 0) & tag)
)
)
traits |= 9;
else traits |= unionTraits(to2);
}
const fields = schema.items || schema.properties;
for (const key in fields) {
const field = fields[key];
traits |= unionTraits(field);
}
if (typeof schema.additionalItems === "object") traits |= unionTraits(schema.additionalItems);
return traits;
};
var unionIsNoop = (schema) => {
if (schema.to !== U || schema.parser !== U || tagFlags[schema.type] & 512) return false;
const fields = schema.anyOf || schema.items || schema.properties;
for (const key in fields) if (!unionIsNoop(fields[key])) return false;
return typeof schema.additionalItems !== "object" || unionIsNoop(schema.additionalItems);
};
var unionFail = (schema, path, input, ...unionErrors) =>
B_throw(
B_makeInvalidInputDetails(schema, unknown, path, input, unionErrors.length ? unionErrors : U),
);
var unionEmitChain = (cases, ctx) => {
if (cases.length === 1) {
const c = cases[0];
if (c.b === "" && c.c === "") return "";
if (c.b === "") return `if(!(${c.c})){${ctx.f("")}}`;
if (c.c === "") return c.b.endsWith(";") ? c.b : c.b + ";";
return `if(${c.c}){${c.b}}else{${ctx.f("")}}`;
}
let code = "";
let caught = false;
let exhaustive = false;
let open = false;
const attempt = (c, idx) => {
open = false;
if (c.b === "") return "break";
const body = c.b.endsWith(";") ? c.b : `${c.b};`;
if (c.f & 1 && (c.f & 8 || caught)) {
caught = open = true;
return `try{${body}break}catch(x){${c.f & 4 ? `x=${ctx.r()}(x);if(x.expected===${ctx.s()}){x=x.unionErrors;x&&(r||(r=[])).push(...x)}else{(r||(r=[])).push(x)}` : `(r||(r=[])).push(${ctx.r()}(x))`}${!(c.f & 8) && unconditional > idx ? `;${ctx.f(",...(r||[])")}` : ""}}`;
}
return `${body}break`;
};
let unconditional = -1;
for (let idx = 0; idx < cases.length; idx++) if (cases[idx].c === "") unconditional = idx;
let last = "";
for (let idx = 0; idx < cases.length; idx++) {
const c = cases[idx];
const shared = c.c !== "" && c.c === last;
if (shared && !open) continue;
const arm = attempt(c, idx);
last = c.c;
if (shared) code = `${code.slice(0, -1)}${arm}}`;
else if (c.c === "") {
code += open ? arm : `${arm};`;
if (!open) {
exhaustive = true;
break;
}
} else code += arm === "break" ? `if(${c.c})break;` : `if(${c.c}){${arm}}`;
}
if (!exhaustive) code += ctx.f(caught ? ",...(r||[])" : "");
return `for(;;){${caught ? "let r;" : ""}${code}}`;
};
var unionOr = (cs) => {
const s2 = cs.map((c) => c.c).join("||");
return cs.length > 1 ? `(${s2})` : s2;
};
var unionNarrowSchema = (schema) => {
const tagFlag = tagFlags[schema.type];
const container = 192;
const narrow = baseSchema(schema.type, false, (input) => {
if (tagFlags[input.s.type] & 1)
return B_refine(input, input.e, [
{
c: (inputVar) => typeCheckCond(input, schema, inputVar),
f: failInvalidType,
},
]);
if (unionRuntimeSame(input.s, narrow))
return tagFlag & container ? B_refine(input, input.e) : input;
if (isLiteral(schema) && tagFlag & 1036) {
input.e = schema;
const output = schema.decoder(input);
input.e = narrow;
return output;
}
return schema.decoder(input);
});
narrow.encoder = schema.encoder;
if (schema.content !== U) setContent(narrow, schema.content);
if (tagFlag & 8192) narrow.class = schema.class;
else if (tagFlag & container) {
narrow.additionalItems = unknown;
if (tagFlag & 64) narrow.properties = immutableEmptyObject;
else narrow.items = immutableEmptyArray;
} else if (tagFlag & 2096) narrow.const = schema.const;
else if (tagFlag & 2 && schema.format !== U && schema.format !== "json") {
narrow.format = schema.format;
narrow.formatFlag = schema.formatFlag;
narrow.noValidation = schema.noValidation;
}
return narrow;
};
var unionWiden = (tagFlag, nan2) =>
tagFlag | (tagFlag & 8256 ? 8256 : tagFlag & tagFlags[numberTag] ? nan2 : 0);
var unionRefDef = (schema) => {
const defs = schema["$defs"],
ref = schema["$ref"];
if (defs === U || ref === U) return U;
const resolved = defs[ref.slice(ref.lastIndexOf("/") + 1)];
return resolved !== U && resolved !== schema ? resolved : U;
};
var unionMask = (schema, mode, nan2) => {
if (mode === 2) {
const resolved = unionRefDef(schema);
if (resolved !== U) return unionMask(resolved, 1, nan2);
}
const tagFlag = tagFlags[schema.type];
if (!mode && tagFlag & 32768) return 0;
if (mode && tagFlag & 256) {
let mask = 0;
const variants = schema.anyOf;
for (let i = 0; i < variants.length; i++) mask |= unionMask(variants[i], 1, nan2);
return mask;
}
return tagFlag & 769 ? -1 : unionWiden(tagFlag, nan2);
};
var unionGroup = (member) => ({
m: member.m,
a: [member],
f: member.f & 16,
p: member.p,
o: false,
});
var unionDiscriminator = (schema) => {
if (isLiteral(schema)) return ["", schema.const];
const fields = schema.properties || schema.items;
for (const key in fields) {
const field = fields[key];
if (isLiteral(field)) return [key, field.const];
}
return U;
};
var unionDropNullish = (variants, other, outputSide) => {
if (
other === U ||
tagFlags[other.type] & 817 ||
other.format === "json" ||
other.format === "env"
)
return variants;
const kept = variants.filter(
(variant) => !(tagFlags[(outputSide ? unionOutput(variant) : variant).type] & 48),
);
return kept.length ? kept : variants;
};
var unionCheckPartial = (input, source, target, variants, outputSide) => {
const other = outputSide ? target : source;
let matched = U;
let unmatched = U;
for (let idx = 0; idx < variants.length; idx++) {
const variant = variants[idx];
const match = outputSide ? unionOutput(variant) : variant;
if (
variant.type === neverTag ||
(outputSide ? match.type === neverTag : unionNeverLink(variant))
)
continue;
if (unionSameType(other, match)) matched || (matched = variant);
else unmatched || (unmatched = variant);
}
if (matched !== U && unmatched !== U) unionInvalid(input, source, target, unmatched, outputSide);
};
var unionPeer = (schema) =>
schema.anyOf?.find((variant) => !(tagFlags[variant.type] & 32816)) || schema;
var unionInvalid = (input, source, target, member, onSource) => {
const it = inputExpression(member);
const conversion = onSource
? `${it} -> ${/* @__PURE__ */ inputExpression(unionPeer(target))}`
: `${/* @__PURE__ */ inputExpression(unionPeer(source))} -> ${it}`;
return B_invalidOperation(
input,
`Ambiguous ${/* @__PURE__ */ inputExpression(source)} -> ${/* @__PURE__ */ inputExpression(target)}. Should ${it} be decoded or ignored? Choose with S.to for ${conversion}, or S.never -> ${it}`,
);
};
var unionAnalyze = (sourceMask, flags, sourceTag, variants, source, nan2) => {
const out = [];
const unknownSource = sourceTag & 1;
const sourceBoundary = sourceTag & 768;
const unionSource = sourceBoundary && sourceMask !== -1;
const sourceDiscriminator = unionDiscriminator(source);
const exact = flags & 1;
const broadObject = flags & 64;
const broadNumber = flags & tagFlags[numberTag];
const numberish = tagFlags[numberTag] | 2048;
for (let i = 0; i < variants.length; i++) {
const s2 = variants[i];
const tag = tagFlags[s2.type];
const inputMask = unionMask(s2, 1, nan2);
const d = unionDiscriminator(s2);
const same = unionRuntimeSame(source, s2);
const discriminatorDisjoint =
sourceDiscriminator !== U &&
d !== U &&
same &&
sourceDiscriminator[0] === d[0] &&
!unionLiteralEqual(sourceDiscriminator[1], d[1]);
const accepts =
!(tag & 32768) &&
!unionNeverLink(s2) &&
!discriminatorDisjoint &&
(!exact ||
(isLiteral(s2) ? unionLiteralEqual(s2.const, source.const) : sourceMask & inputMask));
const native = sourceMask & tag;
const coerces = accepts && !unknownSource && !(unionSource ? native : same);
const output = unionOutput(s2);
const traits = unionTraits(s2);
const sourceDeopt = sourceBoundary && (!unionSource || coerces);
const effect =
output.type === neverTag
? 3
: traits & 4 || sourceDeopt
? 4
: coerces || traits & 8
? 2
: traits & 1 || tag & 9152
? 1
: 0;
out[i] = {
i,
s: s2,
m: accepts
? unknownSource
? inputMask
: unionSource
? native
? inputMask
: s2.type === undefinedTag && sourceMask & 32
? 32
: s2.type === nullTag && sourceMask & 16
? 16
: sourceMask & 2
? 2
: sourceMask
: sourceMask
: 0,
o: !!accepts && output.type !== neverTag,
e: effect,
f:
(traits & 7) |
(effect ? 1 : 0) |
(sourceDeopt ? 4 : 0) |
((!unknownSource && same) || tag & 37633 ? 16 : 0),
p:
(s2.type === objectTag && nestedLoc in s2.properties) ||
(broadObject && tag & 8320) ||
(broadNumber && tag & 2048)
? 0
: d !== U
? 1
: 2,
k: tag & 8192 ? s2.class : s2.format === "env" ? s2.format : s2.type,
n: unionNarrowSchema(s2),
r: tag & 8256 ? 8256 : tag & numberish ? numberish : unionWiden(tag, nan2),
d,
};
}
return out;
};
var unionPlan = (members) => {
var _a;
const sequence = [];
const active = [];
const priority = [];
let total = 0;
let effects = 0;
for (let i = 0; i < members.length; i++) {
const member = members[i];
if (member.e > 1) effects |= member.m;
else if (!member.e) total |= member.m;
}
for (let i = 0; i < members.length; i++) {
const member = members[i];
if (member.m === 0 || (member.e === 1 && !(member.f & 2) && !(member.m & (effects | ~total))))
continue;
const bucketed = member.r !== -1 && (member.m & ~member.r) === 0;
const compatible = member.e < 2 || (member.d !== U && (member.e === 4 || member.d[0] !== ""));
let bucket = bucketed
? member.p === 0
? priority[member.r] || active[member.r]
: active[member.r]
: U;
let open = U;
let broad = false;
if (bucket !== U)
for (let j = 0; j < bucket.t.length; j++) {
const group = bucket.t[j];
const first = group.a[0];
broad || (broad = group.p === 2);
if (
open === U &&
compatible &&
group.o &&
first.k === member.k &&
(first.e < 2 === member.e < 2 || (first.d !== U && first.d[0] === member.d?.[0])) &&
(group.p === 0) === (member.p === 0)
)
open = group;
else if (group.o && group.m & member.m) group.o = false;
}
for (const key in active) {
const other = active[+key];
if (other !== bucket && other.m & member.m) delete active[+key];
}
if (!bucketed) {
for (const key in priority) if (priority[+key].m & member.m) delete priority[+key];
sequence.push(unionGroup(member));
continue;
}
if (bucket !== U && open === U && member.p === 1 && broad) {
delete active[member.r];
bucket = U;
}
if (bucket === U) {
bucket = {
m: 0,
t: [],
};
active[member.r] = bucket;
priority[(_a = member.r)] || (priority[_a] = bucket);
sequence.push(bucket);
}
bucket.m |= member.m;
if (open !== U) {
open.a.push(member);
open.m |= member.m;
open.f &= -17;
} else {
const group = unionGroup(member);
group.o = compatible;
bucket.t.push(group);
}
if (!compatible) delete active[member.r];
}
const plan = [];
for (let i = 0; i < sequence.length; i++) {
const item = sequence[i];
if ("a" in item) plan.push(item);
else plan.push(...item.t.sort((a, b) => a.p - b.p));
}
const later = [];
let laterMask = 0;
let laterBroad = 0;
for (let i = plan.length - 1; i >= 0; i--) {
const group = plan[i];
let key = U;
let values;
for (let j = group.a.length - 1; j >= 0; j--) {
const member = group.a[j];
const d = member.d;
const conflict2 = d === U || key === false || (key !== U && key !== d[0]);
if (key !== U && (conflict2 || values.has(d[1]))) {
member.f |= 8;
group.f |= 2;
}
if (conflict2) key = false;
else {
key = d[0];
(values || (values = new Set())).add(d[1]);
}
}
const head = group.a[0];
const route = head.r;
const semantic = later[route];
let overlaps =
!!(laterMask & group.m) &&
(!!(laterBroad & group.m) ||
key === false ||
semantic === U ||
semantic === false ||
semantic[0] !== key);
if (!overlaps && semantic !== U && semantic !== false) {
for (const value of values)
if (semantic[1].has(value)) {
overlaps = true;
break;
}
}
if (
overlaps ||
(laterMask && tagFlags[head.s.type] & 37633 && (head.s.to !== U || head.s.parser !== U))
)
group.f |= 10;
if (route !== -1 && (group.m & ~route) === 0) {
if (key === false) later[route] = false;
else if (semantic === U) later[route] = [key, values];
else if (semantic !== false) {
if (semantic[0] !== key) later[route] = false;
else for (const value of values) semantic[1].add(value);
}
} else laterBroad |= group.m;
if (laterMask & group.m) group.f |= 32;
laterMask |= group.m;
}
return plan;
};
var unionEmit = (input, self, expectedSchema, plan, toPerCase, trustedSelf) => {
const initialInline = input.i;
let output = B_refine(input);
const awaitAsync = plan.some((group) => group.f & 2);
const outputBySource = [];
let salvaged = "";
let rethrow = "";
let expected = "";
const ctx = {
f: (caught) =>
`${B_embed(input, unionFail.bind(U, expectedSchema, input.path))}(${input.v()}${salvaged}${caught})`,
r: () => rethrow || (rethrow = B_embed(input, getOrRethrow)),
s: () => expected || (expected = B_embed(input, expectedSchema)),
};
const unionDTrusted = (member) => {
const d = member.d;
const tag = tagFlags[member.s.type];
for (const group of plan)
for (const m of group.a) {
if (m === member) continue;
if (m.d !== U ? m.d[0] === d[0] && unionLiteralEqual(m.d[1], d[1]) : m.m & tag)
return false;
}
return true;
};
const compile2 = (member, source, target) => {
const mark = input.g.t;
const caseInput = B_scope(source);
caseInput.u = true;
caseInput.t = source.t;
caseInput.io = false;
caseInput.e = member.s;
if (source.s === target.e) caseInput.s = member.n;
const trustedD =
trustedSelf &&
member.p === 1 &&
!(member.f & 8) &&
member.d[0] !== "" &&
unionDTrusted(member)
? member.d
: U;
if (trustedD !== U) caseInput.s = member.s;
let caseOut;
const options = input.g.o;
input.g.o |= 4;
try {
caseOut = parse(caseInput);
} catch (exn) {
if (!self.perVariant) throw exn;
salvaged += `,${B_embed(input, getOrRethrow(exn))}`;
return U;
} finally {
input.g.o = options;
}
if (member.o) outputBySource[member.i] = caseOut.s;
const cond = {
c: "",
h: [],
};
let body = B_merge(caseOut, cond);
const async = caseOut.f & 1;
output.f |= async;
if (caseOut.t) {
output.t = true;
const itemVar = target.v();
if (async || caseOut.i !== itemVar) {
body += `${itemVar}=${async && awaitAsync ? "await " : ""}${caseOut.i}`;
if (itemVar === operationArgVar) input.g.r = true;
}
}
if (trustedD !== U) {
const dSchema = (member.s.properties || member.s.items)[trustedD[0]];
const dRead = inlinedProperty(source.v(), trustedD[0]);
const dCond =
dSchema.type === nanTag
? `Number.isNaN(${dRead})`
: `${dRead}===${B_inlineConst(caseInput, dSchema)}`;
cond.c = cond.c ? `${dCond}&&${cond.c}` : dCond;
}
return {
c: cond.c,
b: body,
f:
(body !== "" && input.g.t !== mark ? 1 : 0) |
(async && awaitAsync ? 2 : 0) |
(member.f & 8),
};
};
const cases = [];
for (let i = 0; i < plan.length; i++) {
const group = plan[i];
if (group.a.length === 1 && group.f & 16) {
const c = compile2(group.a[0], input, input);
if (c !== U) {
c.f |= group.f & 8;
cases.push(c);
if (c.c === "" && c.b === "") break;
}
continue;
}
const mark = input.g.t;
const groupNarrow = group.a[0].n;
const narrowInput = B_scope(input);
narrowInput.io = false;
narrowInput.e = groupNarrow;
const narrow = parse(narrowInput);
if (tagFlags[groupNarrow.type] & 192) {
const resolved = unionRefDef(input.s);
const sourceVariant =
resolved !== U && resolved.anyOf !== U
? resolved.anyOf.find((v) => v.type === groupNarrow.type)
: U;
if (sourceVariant !== U) narrow.s = sourceVariant;
}
const inner = [];
for (let j = 0; j < group.a.length; j++) {
const c = compile2(group.a[j], narrow, narrowInput);
if (c !== U) {
inner.push(c);
if (c.c === "" && c.b === "") break;
}
}
if (!inner.length) continue;
const cond = {
c: "",
h: [],
};
let body;
let grouped = false;
if (inner.every((c) => c.b === "")) {
if (!inner.some((c) => c.c === "")) {
const fused = unionOr(inner);
body = B_merge(
B_refine(narrow, narrow.s, [
{
c: () => fused,
f: failInvalidType,
},
]),
cond,
);
} else body = B_merge(narrow, cond);
} else {
const narrowCode = B_merge(narrow, cond);
const only = inner.length === 1 ? inner[0] : U;
if (only !== U && narrowCode === "") {
if (only.c !== "") cond.c = cond.c ? `${cond.c}&&${only.c}` : only.c;
body = only.b;
} else {
if (inner.length > 1 && group.f & 32 && inner.every((c) => c.c)) {
const fused = unionOr(inner);
cond.c = cond.c ? `${cond.c}&&${fused}` : fused;
}
body = narrowCode + unionEmitChain(inner, ctx);
grouped = inner.length > 1;
}
}
cases.push({
c: cond.c,
b: body,
f:
(body !== "" && input.g.t !== mark ? 1 : 0) |
(inner.some((c) => c.f & 2) ? 2 : 0) |
(group.f & 8) |
(grouped ? 4 : 0),
});
if (body === "" && cond.c === "") break;
}
const noop = cases.every((c) => c.b === "") && cases.some((c) => c.c === "");
const pure = !noop && cases.length > 0 && cases.every((c) => c.c !== "" && c.b === "");
const asyncDispatch = cases.some((c) => c.f & 2);
if (pure) {
const fused = unionOr(cases);
output = B_refine(
B_refine(
output,
output.s,
[
{
c: () => fused,
f: failInvalidType,
},
],
expectedSchema,
),
);
} else if (!noop) {
const dispatch2 = unionEmitChain(cases, ctx);
if (asyncDispatch) {
const itemVar = input.v();
output.i = `(async(${itemVar})=>{${dispatch2};return ${itemVar}})(${itemVar})`;
} else output.cp += dispatch2;
}
if (!asyncDispatch) output.i = input.i;
let out;
if (output.f & 1) {
output.i = `Promise.resolve(${output.i})`;
output.v = _notVar;
out = output;
} else if (
output.v === _var &&
input.cp === "" &&
output.cp === "" &&
!pure &&
initialInline === "i"
) {
input.hd = "";
input.v = _notVar;
input.i = initialInline;
out = input;
} else out = output;
const outputAnyOf = outputBySource.filter(Boolean);
out.s = outputAnyOf.length ? unionFactory(outputAnyOf) : never_;
if (toPerCase !== U) {
out.io = true;
out.e = unionOutput(toPerCase);
return out;
}
out.e = self;
return B_markOutput(out, input);
};
var unionDecoder = (input) => {
const self = input.e;
const toPerCase =
self.parser === U && self.to !== U && self.to.noValidation !== true ? self.to : U;
let variants = self.anyOf;
if (
(input.io && input.e === input.s) ||
(input.s === self && toPerCase === U && variants.every(unionIsNoop)) ||
(input.s.type === anyOfTag &&
toPerCase === U &&
input.s.anyOf.every((inS, idx) => {
const s2 = variants[idx];
return (
s2 !== U &&
!(tagFlags[inS.type] & 9152) &&
inS.type === s2.type &&
unionLiteralEqual(inS.const, s2.const) &&
inS.to === U &&
s2.to === U
);
}))
)
return input;
const initialTagFlag = tagFlags[input.s.type];
const trustedSelf = input.s === self || self.tr;
if (initialTagFlag & 256 || (input.s.encoder === U && initialTagFlag & 512)) input.s = unknown;
if (variants.every(unionNeverLink))
B_invalidOperation(
input,
`Nothing decodes ${/* @__PURE__ */ inputExpression(self)}. Every member is S.never`,
);
const source = input.s;
variants = unionDropNullish(unionDropNullish(variants, source, false), toPerCase, true);
let expected = self;
if (variants !== self.anyOf) {
expected = copySchema(self);
expected.anyOf = variants;
}
const nan2 = input.g.o & 2 ? 2048 : 0;
let flags = 0;
const sourceLiteral = isLiteral(source);
for (let i = 0; i < variants.length; i++) {
const member = variants[i];
if (sourceLiteral && isLiteral(member) && unionLiteralEqual(member.const, source.const))
flags |= 1;
flags |= tagFlags[member.type] & (64 | tagFlags[numberTag]);
}
const sourceTag = tagFlags[source.type];
if (!(sourceTag & 1) && !(flags & 1)) unionCheckPartial(input, source, self, variants, false);
if (toPerCase !== U) {
const perCase = unionTargetOwns(toPerCase)
? variants.map((v) => (unionOutput(v).type === neverTag ? U : toPerCase))
: unionResolve(input, self, variants, toPerCase);
const attach = self.refiner !== U || self.inputRefiner !== U ? unionRefinerAttacher(self) : U;
variants = variants.map((variant, idx) => {
const to2 = perCase[idx];
return to2 === U && attach === U
? variant
: updateOutput(variant, (mut) => {
if (attach !== U) attach(mut);
if (to2 !== U) mut.to = to2;
});
});
}
return unionEmit(
input,
self,
expected,
unionPlan(unionAnalyze(unionMask(source, 2, nan2), flags, sourceTag, variants, source, nan2)),
toPerCase,
trustedSelf,
);
};
var unionRefinerAttacher = (self) => {
const cached = [];
return (mut) => {
for (let i = 0; i < 2; i++) {
const key = i ? "inputRefiner" : "refiner";
const source = self[key];
if (source !== U) {
const current = mut[key];
mut[key] = (input) => {
const shared = cached[i] || (cached[i] = source(input));
return current === U ? shared : current(input).concat(shared);
};
}
}
};
};
var unionRewrite = (input, variants, map) => {
const anyOf = [];
const has = {};
for (let idx = 0; idx < variants.length; idx++) {
const rewritten = map(variants[idx], idx);
anyOf.push(rewritten);
setHas(has, rewritten.type);
}
const mut = baseSchema(anyOfTag, false, unionDecoder);
mut.anyOf = anyOf;
mut.has = has;
mut.encoder = unionEncoder;
mut.perVariant = input.s.perVariant;
mut.tr = true;
return B_refine(input, unknown, U, mut);
};
var unionTargetOwns = (target) =>
target.noValidation === true ||
tagFlags[unionOutput(target).type] & 512 ||
(target.type === anyOfTag && target.anyOf.some((v) => tagFlags[v.type] & 512));
var unionEncoder = (input, target) => {
input.s;
if (unionTargetOwns(target)) return input;
const variants = unionDropNullish(input.s.anyOf, target, true);
if (target.perVariant && target.anyOf.length === variants.length) {
const targets = target.anyOf;
return targets.every((tv, idx) => tv === variants[idx])
? input
: unionRewrite(input, variants, (_variant, idx) => targets[idx]);
}
const resolved = unionResolve(input, input.s, variants, target);
if (resolved.every((to2) => to2 === U)) return input;
return unionRewrite(input, variants, (variant, idx) => {
const to2 = resolved[idx];
return to2 === U
? variant
: updateOutput(variant, (mut) => {
mut.to = to2;
});
});
};
var unionOpposite = (schema) =>
schema.type === undefinedTag ? nullTag : schema.type === nullTag ? undefinedTag : U;
var unionResolve = (input, source, variants, target) => {
if (source.perVariant) return variants.map(() => target);
if (unionIsTransparent(target)) return unionResolveToUnion(input, source, variants, target);
if (!(tagFlags[target.type] & 1) && !target.noValidation)
unionCheckPartial(input, source, target, variants, true);
return variants.map((variant) => (unionOutput(variant).type === neverTag ? U : target));
};
var unionResolveToUnion = (input, source, variants, target) => {
const targets = target.anyOf;
const matches = [];
const covered = [];
let sourceNullish = 0;
for (let s2 = 0; s2 < variants.length; s2++) {
const sourceVariant = variants[s2];
const sourceOut = unionOutput(sourceVariant);
if (!(sourceVariant.type !== neverTag && sourceOut.type !== neverTag)) continue;
if (sourceOut === target || (target.anyOf !== U && sourceOut.anyOf === target.anyOf)) {
for (let t = 0; t < targets.length; t++) covered[t] = true;
continue;
}
const sameTyped = targets.filter(
(targetVariant, t) =>
targetVariant.type !== neverTag &&
!unionNeverLink(targetVariant) &&
unionSameType(sourceOut, targetVariant) &&
(covered[t] = true),
);
sourceNullish |= tagFlags[sourceOut.type] & 48;
if (sameTyped.length === 1) matches[s2] = sameTyped[0];
else if (sameTyped.length > 1)
matches[s2] =
tagFlags[sourceOut.type] & 9152 && sameTyped.includes(sourceOut)
? sourceOut
: unionFactory(sameTyped);
if (matches[s2] !== U) continue;
const opposite = unionOpposite(sourceOut);
if (opposite !== U)
matches[s2] = targets.find(
(candidate) =>
candidate.type === opposite &&
!unionNeverLink(candidate) &&
unionOutput(candidate).type !== neverTag,
);
if (matches[s2] === U) unionInvalid(input, source, target, sourceOut, true);
}
for (let t = 0; t < targets.length; t++) {
const targetVariant = targets[t];
const opposite = unionOpposite(targetVariant);
if (
targetVariant.type !== neverTag &&
!unionNeverLink(targetVariant) &&
!covered[t] &&
(opposite === U ||
unionOutput(targetVariant).type === neverTag ||
!(sourceNullish & tagFlags[opposite]))
)
unionInvalid(input, source, target, targetVariant, false);
}
return matches.map((matched, idx) => {
if (matched === U) return matched;
const sourceOut = unionOutput(variants[idx]);
return matched === sourceOut ||
(unionIsNoop(matched) &&
matched.refiner === U &&
matched.inputRefiner === U &&
matched.noValidation === U &&
(matched.const === U || unionLiteralEqual(matched.const, sourceOut.const)) &&
!(tagFlags[matched.type] & 9152) &&
unionSameType(matched, sourceOut))
? U
: matched;
});
};
var unionFactory = (schemas) => {
if (!schemas.length) return panic("S.union requires at least one item");
if (schemas.length === 1) return schemas[0];
const has = {};
const anyOf = [];
for (let idx = 0; idx < schemas.length; idx++) {
const schema = schemas[idx];
const nested = unionIsTransparent(schema) ? schema.anyOf : [schema];
for (let j = 0; j < nested.length; j++) {
const member = nested[j];
anyOf.push(member);
setHas(has, member.type);
}
}
const mut = baseSchema(anyOfTag, false, unionDecoder);
mut.anyOf = anyOf;
mut.encoder = unionEncoder;
mut.has = has;
return mut;
};
var internalRefine = (schema, makeRefiner) => {
return updateOutput(schema, (mut) => {
const refiner = makeRefiner(mut);
const existingRefiner = mut.refiner;
if (existingRefiner !== U)
mut.refiner = (input) => {
const arr = existingRefiner(input);
arr.push(...refiner(input));
return arr;
};
else mut.refiner = refiner;
});
};
var getMutErrorMessage = (mut) => {
const em = mut.errorMessage ? { ...mut.errorMessage } : {};
mut.errorMessage = em;
return em;
};
var codecTo = (schema, target, decode, encode) => {
return updateOutput(schema, (mut) => {
const opened = typeof decode === "boolean";
const parser = typeof decode === functionTag ? decode : U;
const serializer = typeof encode === functionTag ? encode : U;
if (serializer !== U || opened) {
const targetMut = copySchema(target);
if (serializer !== U) targetMut.serializer = serializer;
if (opened) targetMut.opens = decode;
mut.to = targetMut;
} else mut.to = target;
if (mut.content !== U && mut.opens === U) mut.opens = true;
if (parser !== U) mut.parser = parser;
});
};
var nullAsUnit = copyTo(nullLiteral, unit);
var Option_getWithDefault = (schema, default_) => {
return updateOutput(schema, (mut) => {
const anyOf = mut.anyOf;
if (anyOf === U) return panic(`Can't set default for ${/* @__PURE__ */ inputExpression(mut)}`);
const outputItems = [];
const originalItems = [];
for (let idx = 0; idx < anyOf.length; idx++) {
const variant = anyOf[idx];
const outputSchema = getOutputSchema(variant);
if (outputSchema.type !== undefinedTag) {
if (!outputItems.includes(outputSchema)) outputItems.push(outputSchema);
originalItems.push(variant);
}
}
const item =
outputItems.length === 0
? panic(`Can't set default for ${/* @__PURE__ */ inputExpression(mut)}`)
: outputItems.length === 1
? outputItems[0]
: unionFactory(outputItems);
if (default_.type === "value") {
const v = default_.value;
try {
getOp(0, 2, unknown, item)(v);
} catch (exn) {
const error = getOrRethrow(exn);
panic(`Invalid default for ${/* @__PURE__ */ inputExpression(mut)}: ${error["message"]}`);
}
const originalItem =
originalItems.length === 1 ? originalItems[0] : unionFactory(originalItems);
try {
mut.default = getOp(0, 1, reverse(originalItem))(v);
} catch (_exn) {}
}
const decodeB = (input) => {
const target = input.e.to;
const output = B_next(
input,
default_.type === "value"
? B_inlineConst(input, Literal_parse(default_.value))
: `${B_embed(input, default_.callback)}()`,
target,
target,
);
if (default_.type === "value") output.v = _var;
return B_refine(output);
};
mut.anyOf = anyOf.map((variant) =>
getOutputSchema(variant).type === undefinedTag
? codecTo(variant, item, decodeB, B_neverSlot)
: variant,
);
});
};
var Option_getOr = (schema, defaultValue) =>
Option_getWithDefault(schema, {
type: "value",
value: defaultValue,
});
var Option_getOrWith = (schema, defaultCb) =>
Option_getWithDefault(schema, {
type: "callback",
callback: defaultCb,
});
var expects = (fnName, expected, got) => `S.${fnName} expects ${expected}, got ${got}`;
var assertNumericBound = (fnName, root, value) => {
const schema = getOutputSchema(root);
const tag = schema.type;
if (tag !== numberTag && tag !== bigintTag)
panic(expects(fnName, "number | bigint schema", inputExpression(schema)));
if (
tag === bigintTag
? typeof value !== bigintTag
: typeof value !== numberTag || Number.isNaN(value)
)
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason: expects(fnName, inputExpression(schema), stringify(value)),
});
return schema;
};
var assertLengthBound = (fnName, root, value) => {
const schema = getOutputSchema(root);
if (schema.type !== stringTag && schema.type !== arrayTag)
panic(expects(fnName, "string | array schema", inputExpression(schema)));
if (typeof value !== numberTag || !Number.isSafeInteger(value) || value < 0)
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason: expects(fnName, "integer >= 0", stringify(value)),
});
return schema;
};
var lit = (value) => (typeof value === bigintTag ? `${value}n` : `${value}`);
var sizeKey = (schema, upper) =>
schema.type === arrayTag
? upper
? "maxItems"
: "minItems"
: schema.type === instanceTag
? upper
? "maxSize"
: "minSize"
: upper
? "maxLength"
: "minLength";
var sizeMember = (schema) => {
const tag = schema.type;
return tag === instanceTag ? ".size" : tag === stringTag || tag === arrayTag ? ".length" : U;
};
var withBounds = (schema, base) => {
const written = schema.bounds ?? 0;
const member = sizeMember(schema);
const sized = member !== U;
const minKey = sized ? sizeKey(schema, false) : "minimum";
const maxKey = sized ? sizeKey(schema, true) : "maximum";
const exMin = written & 4 ? schema.exclusiveMinimum : U;
const exMax = written & 8 ? schema.exclusiveMaximum : U;
const high = exMax !== U ? exMax : written & 2 ? schema[maxKey] : U;
const low =
exMin !== U
? exMin
: written & 1 && !(sized && schema[minKey] === 0 && high !== 0)
? schema[minKey]
: U;
const mo = schema.multipleOf;
const subject0 = sized ? `${base}${member}` : base;
if (low === U && high === U) return mo !== U ? `${subject0} % ${lit(mo)}` : base;
const subject = mo !== U ? `(${subject0} % ${lit(mo)})` : subject0;
if (low === U) return `${subject} ${exMax !== U ? "<" : "<="} ${lit(high)}`;
if (high === U) return `${subject} ${exMin !== U ? ">" : ">="} ${lit(low)}`;
return exMin === U && exMax === U && low === high
? `${subject} == ${lit(low)}`
: `${lit(low)} ${exMin !== U ? "<" : "<="} ${subject} ${exMax !== U ? "<" : "<="} ${lit(high)}`;
};
var setBoundExpression = (mut, schema) => {
if (schema.bounds === U && schema.multipleOf === U) {
const base = schema.expression;
mut.expression = (s2) =>
withBounds(s2, base !== U ? base(s2) : inputExpression(s2, true));
}
};
var exactDivisor = (d) => typeof d === bigintTag || Number.isInteger(d);
var multipleOfValidator = (d) => (value) => {
const ratio = value / d;
return Math.abs(ratio - Math.round(ratio)) < Number.EPSILON * Math.max(Math.abs(ratio), 1);
};
var boundsRefiner = (input) => {
const s2 = input.e;
const written = s2.bounds ?? 0;
const checks = [];
const member = sizeMember(s2);
if (member !== U) {
const minKey = sizeKey(s2, false);
const maxKey = sizeKey(s2, true);
const min = written & 1 ? s2[minKey] : U;
const max = written & 2 ? s2[maxKey] : U;
const em = s2.errorMessage;
if (min !== U && min === max && (em !== U ? em[minKey] : U) === (em !== U ? em[maxKey] : U))
checks.push({
c: (inputVar) => `${inputVar}${member}===${min}`,
f: B_failWithErrorMessage(minKey),
});
else {
if (min)
checks.push({
c: (inputVar) => `${inputVar}${member}>${min - 1}`,
f: B_failWithErrorMessage(minKey),
});
if (max !== U)
checks.push({
c: (inputVar) => `${inputVar}${member}<${max + 1}`,
f: B_failWithErrorMessage(maxKey),
});
}
} else {
const exMin = written & 4 ? s2.exclusiveMinimum : U;
const min = exMin !== U ? exMin : written & 1 ? s2.minimum : U;
if (min !== U)
checks.push({
c: (inputVar) => `${inputVar}${exMin !== U ? ">" : ">="}${lit(min)}`,
f: B_failWithErrorMessage(exMin !== U ? "exclusiveMinimum" : "minimum"),
});
const exMax = written & 8 ? s2.exclusiveMaximum : U;
const max = exMax !== U ? exMax : written & 2 ? s2.maximum : U;
if (max !== U)
checks.push({
c: (inputVar) => `${inputVar}${exMax !== U ? "<" : "<="}${lit(max)}`,
f: B_failWithErrorMessage(exMax !== U ? "exclusiveMaximum" : "maximum"),
});
const mo = s2.multipleOf;
if (mo !== U) {
let cond;
if (typeof mo === bigintTag) cond = (inputVar) => `!(${inputVar}%${lit(mo)})`;
else if (exactDivisor(mo)) cond = (inputVar) => `${inputVar}%${lit(mo)}==0`;
else {
const embedded = B_embed(input, multipleOfValidator(mo));
cond = (inputVar) => `${embedded}(${inputVar})`;
}
checks.push({
c: cond,
f: B_failWithErrorMessage("multipleOf"),
});
}
}
return checks;
};
var updateBounds = (schema, update) =>
schema.bounds !== U || schema.multipleOf !== U
? updateOutput(schema, update)
: internalRefine(schema, (mut) => {
update(mut);
return boundsRefiner;
});
var carryMessage = (schema, key, maybeMessage) =>
maybeMessage === U || key === U
? schema
: updateOutput(schema, (mut) => {
getMutErrorMessage(mut)[key] = maybeMessage;
});
var setBoundMessage = (mut, schema, key, maybeMessage, replaced) => {
const existing = schema.errorMessage;
if (maybeMessage !== U) getMutErrorMessage(mut)[key] = maybeMessage;
else if (existing !== U && existing[key] !== U) getMutErrorMessage(mut)[key] = U;
if (replaced !== U && existing !== U && existing[replaced] !== U)
getMutErrorMessage(mut)[replaced] = U;
};
var narrowsLower = (schema, value, exclusive) => {
const bound = value;
const inclusive = schema.minimum;
const strict2 = schema.exclusiveMinimum;
return (
(inclusive === U || (exclusive ? bound >= inclusive : bound > inclusive)) &&
(strict2 === U || bound > strict2)
);
};
var narrowsUpper = (schema, value, exclusive) => {
const bound = value;
const inclusive = schema.maximum;
const strict2 = schema.exclusiveMaximum;
return (
(inclusive === U || (exclusive ? bound <= inclusive : bound < inclusive)) &&
(strict2 === U || bound < strict2)
);
};
var narrowsSize = (current, value, upper) =>
upper ? current === U || value < current : value > (current ?? 0);
var conflict = (incoming, existing) => {
panic(
`${/* @__PURE__ */ inputExpression(incoming)} contradicts ${/* @__PURE__ */ inputExpression(existing)}`,
);
};
var asBound = (schema, key, bit, value) => {
const mut = {
...schema,
bounds: bit,
};
mut[key] = value;
setBoundExpression(mut, schema);
return mut;
};
var assertLower = (schema, value, exclusive) => {
const key = exclusive ? "exclusiveMinimum" : "minimum";
const bit = exclusive ? 4 : 1;
const bound = value;
const inclusive = schema.maximum;
const strict2 = schema.exclusiveMaximum;
if (inclusive !== U && (exclusive ? bound >= inclusive : bound > inclusive))
conflict(asBound(schema, key, bit, value), asBound(schema, "maximum", 2, inclusive));
if (strict2 !== U && bound >= strict2)
conflict(asBound(schema, key, bit, value), asBound(schema, "exclusiveMaximum", 8, strict2));
};
var assertUpper = (schema, value, exclusive) => {
const key = exclusive ? "exclusiveMaximum" : "maximum";
const bit = exclusive ? 8 : 2;
const bound = value;
const inclusive = schema.minimum;
const strict2 = schema.exclusiveMinimum;
if (inclusive !== U && (exclusive ? bound <= inclusive : bound < inclusive))
conflict(asBound(schema, key, bit, value), asBound(schema, "minimum", 1, inclusive));
if (strict2 !== U && bound <= strict2)
conflict(asBound(schema, key, bit, value), asBound(schema, "exclusiveMinimum", 4, strict2));
};
var assertSize = (schema, value, upper) => {
const otherKey = sizeKey(schema, !upper);
const other = schema[otherKey];
if (other !== U && (upper ? value < other : value > other))
conflict(
asBound(schema, sizeKey(schema, upper), upper ? 2 : 1, value),
asBound(schema, otherKey, upper ? 1 : 2, other),
);
};
var gte = (root, minValue, maybeMessage) => {
const schema = assertNumericBound("gte", root, minValue);
assertLower(schema, minValue, false);
if (!narrowsLower(schema, minValue, false)) {
const written = schema.bounds ?? 0;
return carryMessage(
root,
written & 4 ? "exclusiveMinimum" : written & 1 ? "minimum" : U,
maybeMessage,
);
}
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = ((schema.bounds ?? 0) & -5) | 1;
mut.minimum = minValue;
mut.exclusiveMinimum = U;
setBoundMessage(mut, schema, "minimum", maybeMessage, "exclusiveMinimum");
});
};
var lte = (root, maxValue, maybeMessage) => {
const schema = assertNumericBound("lte", root, maxValue);
assertUpper(schema, maxValue, false);
if (!narrowsUpper(schema, maxValue, false)) {
const written = schema.bounds ?? 0;
return carryMessage(
root,
written & 8 ? "exclusiveMaximum" : written & 2 ? "maximum" : U,
maybeMessage,
);
}
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = ((schema.bounds ?? 0) & -9) | 2;
mut.maximum = maxValue;
mut.exclusiveMaximum = U;
setBoundMessage(mut, schema, "maximum", maybeMessage, "exclusiveMaximum");
});
};
var minLength = (root, length2, maybeMessage) => {
const schema = assertLengthBound("minLength", root, length2);
assertSize(schema, length2, false);
const key = sizeKey(schema, false);
if (!narrowsSize(schema[key], length2, false) && !(length2 === 0 && schema[key] === U))
return carryMessage(root, (schema.bounds ?? 0) & 1 ? key : U, maybeMessage);
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = (schema.bounds ?? 0) | 1;
mut[key] = length2;
setBoundMessage(mut, schema, key, maybeMessage);
});
};
var maxLength = (root, length2, maybeMessage) => {
const schema = assertLengthBound("maxLength", root, length2);
assertSize(schema, length2, true);
const key = sizeKey(schema, true);
if (!narrowsSize(schema[key], length2, true))
return carryMessage(root, (schema.bounds ?? 0) & 2 ? key : U, maybeMessage);
return updateBounds(root, (mut) => {
setBoundExpression(mut, schema);
mut.bounds = (schema.bounds ?? 0) | 2;
mut[key] = length2;
setBoundMessage(mut, schema, key, maybeMessage);
});
};
var nonEmpty = (schema, maybeMessage) =>
minLength(schema, 1, maybeMessage);
var stringFormat = (format, test, flag, expression) =>
initSchema(stringTag, stringDecoderFn, (s2) => {
const re = typeof test === "string" ? new RegExp(test, "i") : test;
s2.format = format;
if (expression) s2.expression = () => expression;
if (flag) s2.formatFlag = flag;
s2.refiner = (input) => {
return [
{
c: (inputVar) =>
`${B_embed(input, re)}${re instanceof RegExp ? ".test" : ""}(${inputVar})`,
f: B_failWithErrorMessage("format"),
},
];
};
});
var ipv4Pattern =
"(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
var ipv6Pattern = () =>
"(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|" +
ipv4Pattern +
")|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)";
var uriPattern = (schemeOptional, scheme) =>
"^(?:" +
(scheme || "[a-z][a-z0-9+\\-.]*") +
":)" +
schemeOptional +
"(?:\\/\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:" +
ipv6Pattern() +
"|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|" +
ipv4Pattern +
"|(?:[a-z0-9\\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\\?(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$";
var uri = stringFormat("uri", uriPattern(""), 1);
var invalidDateRefine = (input) => {
return B_refine(input, input.e, [
{
c: (inputVar) => `!Number.isNaN(${inputVar}.getTime())`,
f: failInvalidType,
},
]);
};
var dateTimeString = initSchema(stringTag, stringDecoderFn, (s2) => {
s2.format = "date-time";
s2.formatFlag = 1;
});
var date = initSchema(
instanceTag,
(input) => {
const inputTagFlag = tagFlags[input.s.type];
if (inputTagFlag & 2) return invalidDateRefine(B_next(input, `new Date(${input.i})`, date));
else if (inputTagFlag & 1) return invalidDateRefine(instanceDecoder(input));
else if (inputTagFlag & 8192 && input.s.class === date.class) return input;
else return B_unsupportedDecode(input, input.s, input.e);
},
(s2) => {
s2.class = Date;
s2.encoder = (input, target) => {
if (tagFlags[target.type] & 2) {
if (input.s.noValidation)
return parse(B_refine(B_next(input, `${input.i}.toISOString()`, dateTimeString, target)));
const output = B_nextVar(input, dateTimeString, target);
output.cp = `let ${output.i};try{${output.i}=${input.v()}.toISOString()}catch(_){${B_embedInvalidInput(input, input.s)}}`;
return parse(B_refine(output));
} else return input;
};
},
);
var panicArity = () =>
panic("Expected at most 3 schemas and a value. Use .with(S.to, ...) for a longer chain");
var dispatch = (n, a, b, c, d, tail, rev, flag) => {
if (n > 4) panicArity();
let data = U;
let immediate = !isOwnSchema(a);
if (immediate) {
((data = a), (a = b), (b = c), (c = d), n--);
if (n < 1 || !isOwnSchema(a)) panicNotSchema();
}
const k = n > 1 && isOwnSchema(b) ? (n > 2 && isOwnSchema(c) ? 3 : 2) : 1;
if (n > k) {
if (immediate || n > k + 1) panic("Expected a Sury schema. The data goes first or last");
data = k > 2 ? (isOwnSchema(d) ? panicArity() : d) : k > 1 ? c : b;
immediate = true;
}
const first = rev ? reverse(a) : a;
const op =
k > 2
? getOp(flag, tail ? 4 : 3, first, b, c, tail)
: k > 1
? getOp(flag, tail ? 3 : 2, first, b, tail)
: getOp(flag, tail ? 2 : 1, first, tail);
return immediate ? op(data) : op;
};
function parseOrThrow(a, b, c, d) {
return dispatch(arguments.length, a, b, c, d, U, false, 8);
}
var getStandardJSONSchema = (schema, options, isOutput2) => {
throw new SuryError({
code: "invalid_operation",
path: pathEmpty,
reason: "~standard.jsonSchema requires S.enableStandardJSONSchema() to be called first",
});
};
Object.defineProperty(schemaPrototype, "toString", {
value: function () {
const input = inputExpression(this);
const output = inputExpression( reverse(this));
return `Schema<${input === output ? input : `${input}, ${output}`}>`;
},
});
Object.defineProperty(schemaPrototype, "~standard", {
get: function () {
const schema = this;
let opFlag = U;
let validateOp;
const standard = {
version: 1,
vendor,
validate: (input) => {
if (opFlag !== globalConfig.f) {
validateOp = getOp(1537, 2, unknown, schema);
opFlag = globalConfig.f;
}
return validateOp(input);
},
jsonSchema: {
input: (options) => getStandardJSONSchema(schema, options, false),
output: (options) => getStandardJSONSchema(schema, options, true),
},
};
valueOptions[valKey] = standard;
Object.defineProperty(schema, "~standard", valueOptions);
return standard;
},
});
var union = (values) => unionFactory(values.map(definitionToSchema));
var nullable2 = (definition, maybeOr) => {
const schema = definitionToSchema(definition);
if (maybeOr !== U) {
const schema2 = unionFactory([schema, nullAsUnit]);
if (typeof maybeOr === functionTag) return Option_getOrWith(schema2, maybeOr);
else return Option_getOr(schema2, maybeOr);
} else return unionFactory([schema, nullLiteral]);
};
const imageSchema = definitionToSchema({
id: float,
created: date,
title: string.with(nonEmpty).with(maxLength, 100),
type: union(["jpg", "png"]),
size: float,
url: uri,
});
const ratingSchema = definitionToSchema({
id: float,
stars: float.with(gte, 1).with(lte, 5),
title: string.with(nonEmpty).with(maxLength, 100),
text: string.with(nonEmpty).with(maxLength, 1e3),
images: array(imageSchema),
});
parseOrThrow(
definitionToSchema({
id: float,
created: date,
title: string.with(nonEmpty).with(maxLength, 100),
brand: string.with(nonEmpty).with(maxLength, 30),
description: string.with(nonEmpty).with(maxLength, 500),
price: float.with(gte, 1).with(lte, 1e4),
discount: float.with(gte, 1).with(lte, 100).with(nullable2),
quantity: float.with(gte, 0).with(lte, 10),
tags: array(string.with(nonEmpty).with(maxLength, 30)),
images: array(imageSchema),
ratings: array(ratingSchema),
}),
)({});