@oomol-lab/open-flow 0.1.0-beta.40 → 0.1.0-beta.41
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +9 -0
- package/dist/browser/{createResourceDialog-BOrW62JW.js → createResourceDialog-DmJk4LsF.js} +28 -29
- package/dist/browser/dist-BhV15xlT.js +300 -0
- package/dist/browser/flow-authoring-node.d.ts +4 -1
- package/dist/browser/flow-authoring.js +7 -10
- package/dist/browser/flow-change.d.ts +3 -15
- package/dist/browser/flow-change.js +1 -2
- package/dist/browser/{editorComponent-0skblWYk.js → flowChanges-Rb1Nz-ph.js} +34187 -15646
- package/dist/browser/{flowRunInputEditorStore-Bgb5vSeS.js → flowRunInputEditorStore-rVbwoTfN.js} +1 -1
- package/dist/browser/{flowWorkspace-DJzQVVtZ.js → flowWorkspace-B04ZIbVq.js} +38861 -39243
- package/dist/browser/licenses.md +16 -0
- package/dist/browser/{markdownContent-D2oHGWc6.js → markdownContent-DP6aYNZN.js} +17 -17
- package/dist/browser/markdownContent-DPkwZqaL.js +44588 -0
- package/dist/browser/preview.css +2 -0
- package/dist/browser/preview.css.d.ts +1 -0
- package/dist/browser/preview.d.ts +15 -0
- package/dist/browser/preview.js +88010 -0
- package/dist/browser/theme.css +7 -1
- package/dist/browser/{typeScriptSession-v9Pb3G6d.js → typeScriptSession-By_yez_b.js} +1 -1
- package/dist/browser/ui.css +1 -1
- package/dist/browser/ui.js +3903 -1421
- package/dist/browser/workbench-contract.d.ts +21 -12
- package/dist/browser/workbench.css +1 -1
- package/dist/browser/workbench.d.ts +3 -1
- package/dist/browser/workbench.js +1174 -1848
- package/dist/browser/workbenchSelect-Bq6KHpKx.js +16033 -0
- package/dist/common/control-api-conformance.js +2606 -2540
- package/dist/common/control-api.d.ts +18 -10
- package/dist/common/control-api.js +2428 -2381
- package/dist/common/control-requests.js +4 -8
- package/dist/common/flow-encoding.js +1 -2
- package/dist/common/flow-graph.d.ts +1 -1
- package/dist/common/flow-promptTemplate.d.ts +4 -0
- package/dist/common/flow-schema.d.ts +1 -0
- package/dist/common/flow-semantics.d.ts +2 -1
- package/dist/common/flow-semantics.js +2780 -2770
- package/dist/common/integration-trigger.js +724 -721
- package/dist/common/mcp.js +789 -739
- package/dist/common/poll-trigger.js +40 -37
- package/dist/common/provider-triggers.js +611 -608
- package/dist/common/providerIconSprite.d.ts +25 -0
- package/dist/common/runtime-contract.js +2 -1
- package/dist/common/scheduler.d.ts +2 -0
- package/dist/common/scheduler.js +1585 -1549
- package/dist/common/webhook-trigger.js +1 -2
- package/dist/index.d.ts +19 -0
- package/package.json +9 -1
- package/dist/browser/flowChanges-3o9Vs_1I.js +0 -10137
- package/dist/browser/inputValues-DkDT6u0o.js +0 -43
- package/dist/browser/lite-BA96NG4M.js +0 -8549
- package/dist/browser/workbenchSelect-B5zXyaaX.js +0 -6423
|
@@ -139,55 +139,55 @@ var l = /^(\d\d\d\d)-(\d\d)-(\d\d)$/, u = [
|
|
|
139
139
|
let [t, n, ...r] = e.split("@");
|
|
140
140
|
return !t || !n || r.length !== 0 || t.length > 64 || n.length > 253 || t[0] === "." || t.endsWith(".") || t.includes("..") || !/^[a-z0-9.-]+$/i.test(n) || !/^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+$/i.test(t) ? !1 : n.split(".").every((e) => /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i.test(e));
|
|
141
141
|
}, oe = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/, se = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i, ce = (e) => e.length > 1 && e.length < 80 && (/^P\d+([.,]\d+)?W$/.test(e) || /^P[\dYMDTHS]*(\d[.,]\d+)?[YMDHS]$/.test(e) && /^P([.,\d]+Y)?([.,\d]+M)?([.,\d]+D)?(T([.,\d]+H)?([.,\d]+M)?([.,\d]+S)?)?$/.test(e));
|
|
142
|
-
function
|
|
142
|
+
function le(e) {
|
|
143
143
|
return e.test.bind(e);
|
|
144
144
|
}
|
|
145
|
-
var
|
|
146
|
-
date:
|
|
147
|
-
time:
|
|
148
|
-
"date-time":
|
|
145
|
+
var ue = {
|
|
146
|
+
date: fe,
|
|
147
|
+
time: pe.bind(void 0, !1),
|
|
148
|
+
"date-time": he,
|
|
149
149
|
duration: ce,
|
|
150
|
-
uri:
|
|
151
|
-
"uri-reference":
|
|
152
|
-
"uri-template":
|
|
153
|
-
url:
|
|
150
|
+
uri: ve,
|
|
151
|
+
"uri-reference": le(p),
|
|
152
|
+
"uri-template": le(m),
|
|
153
|
+
url: le(ee),
|
|
154
154
|
email: ae,
|
|
155
|
-
hostname:
|
|
156
|
-
ipv4:
|
|
157
|
-
ipv6:
|
|
158
|
-
regex:
|
|
159
|
-
uuid:
|
|
160
|
-
"json-pointer":
|
|
161
|
-
"json-pointer-uri-fragment":
|
|
162
|
-
"relative-json-pointer":
|
|
155
|
+
hostname: le(f),
|
|
156
|
+
ipv4: le(oe),
|
|
157
|
+
ipv6: le(se),
|
|
158
|
+
regex: be,
|
|
159
|
+
uuid: le(te),
|
|
160
|
+
"json-pointer": le(ne),
|
|
161
|
+
"json-pointer-uri-fragment": le(re),
|
|
162
|
+
"relative-json-pointer": le(ie)
|
|
163
163
|
};
|
|
164
|
-
function
|
|
164
|
+
function de(e) {
|
|
165
165
|
return e % 4 == 0 && (e % 100 != 0 || e % 400 == 0);
|
|
166
166
|
}
|
|
167
|
-
function
|
|
167
|
+
function fe(e) {
|
|
168
168
|
let t = e.match(l);
|
|
169
169
|
if (!t) return !1;
|
|
170
170
|
let n = +t[1], r = +t[2], i = +t[3];
|
|
171
|
-
return r >= 1 && r <= 12 && i >= 1 && i <= (r == 2 &&
|
|
171
|
+
return r >= 1 && r <= 12 && i >= 1 && i <= (r == 2 && de(n) ? 29 : u[r]);
|
|
172
172
|
}
|
|
173
|
-
function
|
|
173
|
+
function pe(e, t) {
|
|
174
174
|
let n = t.match(d);
|
|
175
175
|
if (!n) return !1;
|
|
176
176
|
let r = +n[1], i = +n[2], a = +n[3], o = !!n[5];
|
|
177
177
|
return (r <= 23 && i <= 59 && a <= 59 || r == 23 && i == 59 && a == 60) && (!e || o);
|
|
178
178
|
}
|
|
179
|
-
var
|
|
180
|
-
function
|
|
181
|
-
let t = e.split(
|
|
182
|
-
return t.length == 2 &&
|
|
179
|
+
var me = /t|\s/i;
|
|
180
|
+
function he(e) {
|
|
181
|
+
let t = e.split(me);
|
|
182
|
+
return t.length == 2 && fe(t[0]) && pe(!0, t[1]);
|
|
183
183
|
}
|
|
184
|
-
var
|
|
185
|
-
function
|
|
186
|
-
return
|
|
184
|
+
var ge = /\/|:/, _e = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[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}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[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})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[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})*)?$/i;
|
|
185
|
+
function ve(e) {
|
|
186
|
+
return ge.test(e) && _e.test(e);
|
|
187
187
|
}
|
|
188
|
-
var
|
|
189
|
-
function
|
|
190
|
-
if (
|
|
188
|
+
var ye = /[^\\]\\Z/;
|
|
189
|
+
function be(e) {
|
|
190
|
+
if (ye.test(e)) return !1;
|
|
191
191
|
try {
|
|
192
192
|
return new RegExp(e, "u"), !0;
|
|
193
193
|
} catch {
|
|
@@ -196,14 +196,14 @@ function ye(e) {
|
|
|
196
196
|
}
|
|
197
197
|
//#endregion
|
|
198
198
|
//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/ucs2-length.js
|
|
199
|
-
function
|
|
199
|
+
function xe(e) {
|
|
200
200
|
let t = 0, n = e.length, r = 0, i;
|
|
201
201
|
for (; r < n;) t++, i = e.charCodeAt(r++), i >= 55296 && i <= 56319 && r < n && (i = e.charCodeAt(r), (i & 64512) == 56320 && r++);
|
|
202
202
|
return t;
|
|
203
203
|
}
|
|
204
204
|
//#endregion
|
|
205
205
|
//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/validate.js
|
|
206
|
-
function
|
|
206
|
+
function h(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d = Object.create(null)) {
|
|
207
207
|
if (r === !0) return {
|
|
208
208
|
valid: !0,
|
|
209
209
|
errors: []
|
|
@@ -229,10 +229,10 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
229
229
|
break;
|
|
230
230
|
default: throw Error(`Instances of "${f}" type are not supported.`);
|
|
231
231
|
}
|
|
232
|
-
let { $ref: m, $recursiveRef: ee, $recursiveAnchor: te, type: ne, const: re, enum: ie, required: ae, not: oe, anyOf: se, allOf: ce, oneOf:
|
|
232
|
+
let { $ref: m, $recursiveRef: ee, $recursiveAnchor: te, type: ne, const: re, enum: ie, required: ae, not: oe, anyOf: se, allOf: ce, oneOf: le, if: de, then: fe, else: pe, format: me, properties: he, patternProperties: ge, additionalProperties: _e, unevaluatedProperties: ve, minProperties: ye, maxProperties: be, propertyNames: Se, dependentRequired: Ce, dependentSchemas: we, dependencies: Te, prefixItems: Ee, items: De, additionalItems: Oe, unevaluatedItems: g, contains: _, minContains: v, maxContains: y, minItems: b, maxItems: x, uniqueItems: ke, minimum: S, maximum: Ae, exclusiveMinimum: je, exclusiveMaximum: Me, multipleOf: Ne, minLength: Pe, maxLength: Fe, pattern: Ie, __absolute_ref__: Le, __absolute_recursive_ref__: C } = r, w = [];
|
|
233
233
|
if (te === !0 && s === null && (s = r), ee === "#") {
|
|
234
|
-
let t = s === null ? a[
|
|
235
|
-
c.valid ||
|
|
234
|
+
let t = s === null ? a[C] : s, n = `${u}/$recursiveRef`, c = h(e, s === null ? r : s, i, a, o, t, l, n, d);
|
|
235
|
+
c.valid || w.push({
|
|
236
236
|
instanceLocation: l,
|
|
237
237
|
keyword: "$recursiveRef",
|
|
238
238
|
keywordLocation: n,
|
|
@@ -240,20 +240,20 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
240
240
|
}, ...c.errors);
|
|
241
241
|
}
|
|
242
242
|
if (m !== void 0) {
|
|
243
|
-
let t = a[
|
|
243
|
+
let t = a[Le || m];
|
|
244
244
|
if (t === void 0) {
|
|
245
245
|
let e = `Unresolved $ref "${m}".`;
|
|
246
|
-
throw
|
|
246
|
+
throw Le && Le !== m && (e += ` Absolute URI "${Le}".`), e += `\nKnown schemas:\n- ${Object.keys(a).join("\n- ")}`, Error(e);
|
|
247
247
|
}
|
|
248
|
-
let n = `${u}/$ref`, r =
|
|
249
|
-
if (r.valid ||
|
|
248
|
+
let n = `${u}/$ref`, r = h(e, t, i, a, o, s, l, n, d);
|
|
249
|
+
if (r.valid || w.push({
|
|
250
250
|
instanceLocation: l,
|
|
251
251
|
keyword: "$ref",
|
|
252
252
|
keywordLocation: n,
|
|
253
253
|
error: "A subschema had errors."
|
|
254
254
|
}, ...r.errors), i === "4" || i === "7") return {
|
|
255
|
-
valid:
|
|
256
|
-
errors:
|
|
255
|
+
valid: w.length === 0,
|
|
256
|
+
errors: w
|
|
257
257
|
};
|
|
258
258
|
}
|
|
259
259
|
if (Array.isArray(ne)) {
|
|
@@ -262,60 +262,60 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
262
262
|
n = !0;
|
|
263
263
|
break;
|
|
264
264
|
}
|
|
265
|
-
n ||
|
|
265
|
+
n || w.push({
|
|
266
266
|
instanceLocation: l,
|
|
267
267
|
keyword: "type",
|
|
268
268
|
keywordLocation: `${u}/type`,
|
|
269
269
|
error: `Instance type "${p}" is invalid. Expected "${ne.join("\", \"")}".`
|
|
270
270
|
});
|
|
271
|
-
} else ne === "integer" ? (p !== "number" || e % 1 || e !== e) &&
|
|
271
|
+
} else ne === "integer" ? (p !== "number" || e % 1 || e !== e) && w.push({
|
|
272
272
|
instanceLocation: l,
|
|
273
273
|
keyword: "type",
|
|
274
274
|
keywordLocation: `${u}/type`,
|
|
275
275
|
error: `Instance type "${p}" is invalid. Expected "${ne}".`
|
|
276
|
-
}) : ne !== void 0 && p !== ne &&
|
|
276
|
+
}) : ne !== void 0 && p !== ne && w.push({
|
|
277
277
|
instanceLocation: l,
|
|
278
278
|
keyword: "type",
|
|
279
279
|
keywordLocation: `${u}/type`,
|
|
280
280
|
error: `Instance type "${p}" is invalid. Expected "${ne}".`
|
|
281
281
|
});
|
|
282
|
-
if (re !== void 0 && (p === "object" || p === "array" ? t(e, re) ||
|
|
282
|
+
if (re !== void 0 && (p === "object" || p === "array" ? t(e, re) || w.push({
|
|
283
283
|
instanceLocation: l,
|
|
284
284
|
keyword: "const",
|
|
285
285
|
keywordLocation: `${u}/const`,
|
|
286
286
|
error: `Instance does not match ${JSON.stringify(re)}.`
|
|
287
|
-
}) : e !== re &&
|
|
287
|
+
}) : e !== re && w.push({
|
|
288
288
|
instanceLocation: l,
|
|
289
289
|
keyword: "const",
|
|
290
290
|
keywordLocation: `${u}/const`,
|
|
291
291
|
error: `Instance does not match ${JSON.stringify(re)}.`
|
|
292
|
-
})), ie !== void 0 && (p === "object" || p === "array" ? ie.some((n) => t(e, n)) ||
|
|
292
|
+
})), ie !== void 0 && (p === "object" || p === "array" ? ie.some((n) => t(e, n)) || w.push({
|
|
293
293
|
instanceLocation: l,
|
|
294
294
|
keyword: "enum",
|
|
295
295
|
keywordLocation: `${u}/enum`,
|
|
296
296
|
error: `Instance does not match any of ${JSON.stringify(ie)}.`
|
|
297
|
-
}) : ie.some((t) => e === t) ||
|
|
297
|
+
}) : ie.some((t) => e === t) || w.push({
|
|
298
298
|
instanceLocation: l,
|
|
299
299
|
keyword: "enum",
|
|
300
300
|
keywordLocation: `${u}/enum`,
|
|
301
301
|
error: `Instance does not match any of ${JSON.stringify(ie)}.`
|
|
302
302
|
})), oe !== void 0) {
|
|
303
303
|
let t = `${u}/not`;
|
|
304
|
-
|
|
304
|
+
h(e, oe, i, a, o, s, l, t).valid && w.push({
|
|
305
305
|
instanceLocation: l,
|
|
306
306
|
keyword: "not",
|
|
307
307
|
keywordLocation: t,
|
|
308
308
|
error: "Instance matched \"not\" schema."
|
|
309
309
|
});
|
|
310
310
|
}
|
|
311
|
-
let
|
|
311
|
+
let Re = [];
|
|
312
312
|
if (se !== void 0) {
|
|
313
|
-
let t = `${u}/anyOf`, n =
|
|
313
|
+
let t = `${u}/anyOf`, n = w.length, r = !1;
|
|
314
314
|
for (let n = 0; n < se.length; n++) {
|
|
315
|
-
let c = se[n], u = Object.create(d), f =
|
|
316
|
-
|
|
315
|
+
let c = se[n], u = Object.create(d), f = h(e, c, i, a, o, te === !0 ? s : null, l, `${t}/${n}`, u);
|
|
316
|
+
w.push(...f.errors), r ||= f.valid, f.valid && Re.push(u);
|
|
317
317
|
}
|
|
318
|
-
r ?
|
|
318
|
+
r ? w.length = n : w.splice(n, 0, {
|
|
319
319
|
instanceLocation: l,
|
|
320
320
|
keyword: "anyOf",
|
|
321
321
|
keywordLocation: t,
|
|
@@ -323,45 +323,45 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
323
323
|
});
|
|
324
324
|
}
|
|
325
325
|
if (ce !== void 0) {
|
|
326
|
-
let t = `${u}/allOf`, n =
|
|
326
|
+
let t = `${u}/allOf`, n = w.length, r = !0;
|
|
327
327
|
for (let n = 0; n < ce.length; n++) {
|
|
328
|
-
let c = ce[n], u = Object.create(d), f =
|
|
329
|
-
|
|
328
|
+
let c = ce[n], u = Object.create(d), f = h(e, c, i, a, o, te === !0 ? s : null, l, `${t}/${n}`, u);
|
|
329
|
+
w.push(...f.errors), r &&= f.valid, f.valid && Re.push(u);
|
|
330
330
|
}
|
|
331
|
-
r ?
|
|
331
|
+
r ? w.length = n : w.splice(n, 0, {
|
|
332
332
|
instanceLocation: l,
|
|
333
333
|
keyword: "allOf",
|
|
334
334
|
keywordLocation: t,
|
|
335
335
|
error: "Instance does not match every subschema."
|
|
336
336
|
});
|
|
337
337
|
}
|
|
338
|
-
if (
|
|
339
|
-
let t = `${u}/oneOf`, n =
|
|
340
|
-
let c = Object.create(d), u =
|
|
341
|
-
return
|
|
338
|
+
if (le !== void 0) {
|
|
339
|
+
let t = `${u}/oneOf`, n = w.length, r = le.filter((n, r) => {
|
|
340
|
+
let c = Object.create(d), u = h(e, n, i, a, o, te === !0 ? s : null, l, `${t}/${r}`, c);
|
|
341
|
+
return w.push(...u.errors), u.valid && Re.push(c), u.valid;
|
|
342
342
|
}).length;
|
|
343
|
-
r === 1 ?
|
|
343
|
+
r === 1 ? w.length = n : w.splice(n, 0, {
|
|
344
344
|
instanceLocation: l,
|
|
345
345
|
keyword: "oneOf",
|
|
346
346
|
keywordLocation: t,
|
|
347
347
|
error: `Instance does not match exactly one subschema (${r} matches).`
|
|
348
348
|
});
|
|
349
349
|
}
|
|
350
|
-
if ((p === "object" || p === "array") && Object.assign(d, ...
|
|
350
|
+
if ((p === "object" || p === "array") && Object.assign(d, ...Re), de !== void 0) {
|
|
351
351
|
let t = `${u}/if`;
|
|
352
|
-
if (
|
|
353
|
-
if (
|
|
354
|
-
let n =
|
|
355
|
-
n.valid ||
|
|
352
|
+
if (h(e, de, i, a, o, s, l, t, d).valid) {
|
|
353
|
+
if (fe !== void 0) {
|
|
354
|
+
let n = h(e, fe, i, a, o, s, l, `${u}/then`, d);
|
|
355
|
+
n.valid || w.push({
|
|
356
356
|
instanceLocation: l,
|
|
357
357
|
keyword: "if",
|
|
358
358
|
keywordLocation: t,
|
|
359
359
|
error: "Instance does not match \"then\" schema."
|
|
360
360
|
}, ...n.errors);
|
|
361
361
|
}
|
|
362
|
-
} else if (
|
|
363
|
-
let n =
|
|
364
|
-
n.valid ||
|
|
362
|
+
} else if (pe !== void 0) {
|
|
363
|
+
let n = h(e, pe, i, a, o, s, l, `${u}/else`, d);
|
|
364
|
+
n.valid || w.push({
|
|
365
365
|
instanceLocation: l,
|
|
366
366
|
keyword: "if",
|
|
367
367
|
keywordLocation: t,
|
|
@@ -370,28 +370,28 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
370
370
|
}
|
|
371
371
|
}
|
|
372
372
|
if (p === "object") {
|
|
373
|
-
if (ae !== void 0) for (let t of ae) t in e ||
|
|
373
|
+
if (ae !== void 0) for (let t of ae) t in e || w.push({
|
|
374
374
|
instanceLocation: l,
|
|
375
375
|
keyword: "required",
|
|
376
376
|
keywordLocation: `${u}/required`,
|
|
377
377
|
error: `Instance does not have required property "${t}".`
|
|
378
378
|
});
|
|
379
379
|
let t = Object.keys(e);
|
|
380
|
-
if (
|
|
380
|
+
if (ye !== void 0 && t.length < ye && w.push({
|
|
381
381
|
instanceLocation: l,
|
|
382
382
|
keyword: "minProperties",
|
|
383
383
|
keywordLocation: `${u}/minProperties`,
|
|
384
|
-
error: `Instance does not have at least ${
|
|
385
|
-
}),
|
|
384
|
+
error: `Instance does not have at least ${ye} properties.`
|
|
385
|
+
}), be !== void 0 && t.length > be && w.push({
|
|
386
386
|
instanceLocation: l,
|
|
387
387
|
keyword: "maxProperties",
|
|
388
388
|
keywordLocation: `${u}/maxProperties`,
|
|
389
|
-
error: `Instance does not have at least ${
|
|
390
|
-
}),
|
|
389
|
+
error: `Instance does not have at least ${be} properties.`
|
|
390
|
+
}), Se !== void 0) {
|
|
391
391
|
let t = `${u}/propertyNames`;
|
|
392
392
|
for (let r in e) {
|
|
393
|
-
let e = `${l}/${n(r)}`, c =
|
|
394
|
-
c.valid ||
|
|
393
|
+
let e = `${l}/${n(r)}`, c = h(r, Se, i, a, o, s, e, t);
|
|
394
|
+
c.valid || w.push({
|
|
395
395
|
instanceLocation: l,
|
|
396
396
|
keyword: "propertyNames",
|
|
397
397
|
keywordLocation: t,
|
|
@@ -399,11 +399,11 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
399
399
|
}, ...c.errors);
|
|
400
400
|
}
|
|
401
401
|
}
|
|
402
|
-
if (
|
|
402
|
+
if (Ce !== void 0) {
|
|
403
403
|
let t = `${u}/dependantRequired`;
|
|
404
|
-
for (let n in
|
|
405
|
-
let r =
|
|
406
|
-
for (let i of r) i in e ||
|
|
404
|
+
for (let n in Ce) if (n in e) {
|
|
405
|
+
let r = Ce[n];
|
|
406
|
+
for (let i of r) i in e || w.push({
|
|
407
407
|
instanceLocation: l,
|
|
408
408
|
keyword: "dependentRequired",
|
|
409
409
|
keywordLocation: t,
|
|
@@ -411,11 +411,11 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
411
411
|
});
|
|
412
412
|
}
|
|
413
413
|
}
|
|
414
|
-
if (
|
|
414
|
+
if (we !== void 0) for (let t in we) {
|
|
415
415
|
let r = `${u}/dependentSchemas`;
|
|
416
416
|
if (t in e) {
|
|
417
|
-
let c =
|
|
418
|
-
c.valid ||
|
|
417
|
+
let c = h(e, we[t], i, a, o, s, l, `${r}/${n(t)}`, d);
|
|
418
|
+
c.valid || w.push({
|
|
419
419
|
instanceLocation: l,
|
|
420
420
|
keyword: "dependentSchemas",
|
|
421
421
|
keywordLocation: r,
|
|
@@ -423,19 +423,19 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
423
423
|
}, ...c.errors);
|
|
424
424
|
}
|
|
425
425
|
}
|
|
426
|
-
if (
|
|
426
|
+
if (Te !== void 0) {
|
|
427
427
|
let t = `${u}/dependencies`;
|
|
428
|
-
for (let r in
|
|
429
|
-
let c =
|
|
430
|
-
if (Array.isArray(c)) for (let n of c) n in e ||
|
|
428
|
+
for (let r in Te) if (r in e) {
|
|
429
|
+
let c = Te[r];
|
|
430
|
+
if (Array.isArray(c)) for (let n of c) n in e || w.push({
|
|
431
431
|
instanceLocation: l,
|
|
432
432
|
keyword: "dependencies",
|
|
433
433
|
keywordLocation: t,
|
|
434
434
|
error: `Instance has "${r}" but does not have "${n}".`
|
|
435
435
|
});
|
|
436
436
|
else {
|
|
437
|
-
let u =
|
|
438
|
-
u.valid ||
|
|
437
|
+
let u = h(e, c, i, a, o, s, l, `${t}/${n(r)}`);
|
|
438
|
+
u.valid || w.push({
|
|
439
439
|
instanceLocation: l,
|
|
440
440
|
keyword: "dependencies",
|
|
441
441
|
keywordLocation: t,
|
|
@@ -445,13 +445,13 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
445
445
|
}
|
|
446
446
|
}
|
|
447
447
|
let r = Object.create(null), c = !1;
|
|
448
|
-
if (
|
|
448
|
+
if (he !== void 0) {
|
|
449
449
|
let t = `${u}/properties`;
|
|
450
|
-
for (let u in
|
|
450
|
+
for (let u in he) {
|
|
451
451
|
if (!(u in e)) continue;
|
|
452
|
-
let f = `${l}/${n(u)}`, p =
|
|
452
|
+
let f = `${l}/${n(u)}`, p = h(e[u], he[u], i, a, o, s, f, `${t}/${n(u)}`);
|
|
453
453
|
if (p.valid) d[u] = r[u] = !0;
|
|
454
|
-
else if (c = o,
|
|
454
|
+
else if (c = o, w.push({
|
|
455
455
|
instanceLocation: l,
|
|
456
456
|
keyword: "properties",
|
|
457
457
|
keywordLocation: t,
|
|
@@ -459,14 +459,14 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
459
459
|
}, ...p.errors), c) break;
|
|
460
460
|
}
|
|
461
461
|
}
|
|
462
|
-
if (!c &&
|
|
462
|
+
if (!c && ge !== void 0) {
|
|
463
463
|
let t = `${u}/patternProperties`;
|
|
464
|
-
for (let u in
|
|
465
|
-
let f = new RegExp(u, "u"), p =
|
|
464
|
+
for (let u in ge) {
|
|
465
|
+
let f = new RegExp(u, "u"), p = ge[u];
|
|
466
466
|
for (let m in e) {
|
|
467
467
|
if (!f.test(m)) continue;
|
|
468
|
-
let ee = `${l}/${n(m)}`, te =
|
|
469
|
-
te.valid ? d[m] = r[m] = !0 : (c = o,
|
|
468
|
+
let ee = `${l}/${n(m)}`, te = h(e[m], p, i, a, o, s, ee, `${t}/${n(u)}`);
|
|
469
|
+
te.valid ? d[m] = r[m] = !0 : (c = o, w.push({
|
|
470
470
|
instanceLocation: l,
|
|
471
471
|
keyword: "patternProperties",
|
|
472
472
|
keywordLocation: t,
|
|
@@ -475,23 +475,23 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
475
475
|
}
|
|
476
476
|
}
|
|
477
477
|
}
|
|
478
|
-
if (!c &&
|
|
478
|
+
if (!c && _e !== void 0) {
|
|
479
479
|
let t = `${u}/additionalProperties`;
|
|
480
480
|
for (let u in e) {
|
|
481
481
|
if (r[u]) continue;
|
|
482
|
-
let f = `${l}/${n(u)}`, p =
|
|
483
|
-
p.valid ? d[u] = !0 : (c = o,
|
|
482
|
+
let f = `${l}/${n(u)}`, p = h(e[u], _e, i, a, o, s, f, t);
|
|
483
|
+
p.valid ? d[u] = !0 : (c = o, w.push({
|
|
484
484
|
instanceLocation: l,
|
|
485
485
|
keyword: "additionalProperties",
|
|
486
486
|
keywordLocation: t,
|
|
487
487
|
error: `Property "${u}" does not match additional properties schema.`
|
|
488
488
|
}, ...p.errors));
|
|
489
489
|
}
|
|
490
|
-
} else if (!c &&
|
|
490
|
+
} else if (!c && ve !== void 0) {
|
|
491
491
|
let t = `${u}/unevaluatedProperties`;
|
|
492
492
|
for (let r in e) if (!d[r]) {
|
|
493
|
-
let c = `${l}/${n(r)}`, u =
|
|
494
|
-
u.valid ? d[r] = !0 :
|
|
493
|
+
let c = `${l}/${n(r)}`, u = h(e[r], ve, i, a, o, s, c, t);
|
|
494
|
+
u.valid ? d[r] = !0 : w.push({
|
|
495
495
|
instanceLocation: l,
|
|
496
496
|
keyword: "unevaluatedProperties",
|
|
497
497
|
keywordLocation: t,
|
|
@@ -500,23 +500,23 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
500
500
|
}
|
|
501
501
|
}
|
|
502
502
|
} else if (p === "array") {
|
|
503
|
-
|
|
503
|
+
x !== void 0 && e.length > x && w.push({
|
|
504
504
|
instanceLocation: l,
|
|
505
505
|
keyword: "maxItems",
|
|
506
506
|
keywordLocation: `${u}/maxItems`,
|
|
507
|
-
error: `Array has too many items (${e.length} > ${
|
|
508
|
-
}),
|
|
507
|
+
error: `Array has too many items (${e.length} > ${x}).`
|
|
508
|
+
}), b !== void 0 && e.length < b && w.push({
|
|
509
509
|
instanceLocation: l,
|
|
510
510
|
keyword: "minItems",
|
|
511
511
|
keywordLocation: `${u}/minItems`,
|
|
512
|
-
error: `Array has too few items (${e.length} < ${
|
|
512
|
+
error: `Array has too few items (${e.length} < ${b}).`
|
|
513
513
|
});
|
|
514
514
|
let n = e.length, r = 0, c = !1;
|
|
515
|
-
if (
|
|
516
|
-
let t = `${u}/prefixItems`, f = Math.min(
|
|
515
|
+
if (Ee !== void 0) {
|
|
516
|
+
let t = `${u}/prefixItems`, f = Math.min(Ee.length, n);
|
|
517
517
|
for (; r < f; r++) {
|
|
518
|
-
let n =
|
|
519
|
-
if (d[r] = !0, !n.valid && (c = o,
|
|
518
|
+
let n = h(e[r], Ee[r], i, a, o, s, `${l}/${r}`, `${t}/${r}`);
|
|
519
|
+
if (d[r] = !0, !n.valid && (c = o, w.push({
|
|
520
520
|
instanceLocation: l,
|
|
521
521
|
keyword: "prefixItems",
|
|
522
522
|
keywordLocation: t,
|
|
@@ -524,13 +524,13 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
524
524
|
}, ...n.errors), c)) break;
|
|
525
525
|
}
|
|
526
526
|
}
|
|
527
|
-
if (
|
|
527
|
+
if (De !== void 0) {
|
|
528
528
|
let t = `${u}/items`;
|
|
529
|
-
if (Array.isArray(
|
|
530
|
-
let u = Math.min(
|
|
529
|
+
if (Array.isArray(De)) {
|
|
530
|
+
let u = Math.min(De.length, n);
|
|
531
531
|
for (; r < u; r++) {
|
|
532
|
-
let n =
|
|
533
|
-
if (d[r] = !0, !n.valid && (c = o,
|
|
532
|
+
let n = h(e[r], De[r], i, a, o, s, `${l}/${r}`, `${t}/${r}`);
|
|
533
|
+
if (d[r] = !0, !n.valid && (c = o, w.push({
|
|
534
534
|
instanceLocation: l,
|
|
535
535
|
keyword: "items",
|
|
536
536
|
keywordLocation: t,
|
|
@@ -538,19 +538,19 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
538
538
|
}, ...n.errors), c)) break;
|
|
539
539
|
}
|
|
540
540
|
} else for (; r < n; r++) {
|
|
541
|
-
let n =
|
|
542
|
-
if (d[r] = !0, !n.valid && (c = o,
|
|
541
|
+
let n = h(e[r], De, i, a, o, s, `${l}/${r}`, t);
|
|
542
|
+
if (d[r] = !0, !n.valid && (c = o, w.push({
|
|
543
543
|
instanceLocation: l,
|
|
544
544
|
keyword: "items",
|
|
545
545
|
keywordLocation: t,
|
|
546
546
|
error: "Items did not match schema."
|
|
547
547
|
}, ...n.errors), c)) break;
|
|
548
548
|
}
|
|
549
|
-
if (!c &&
|
|
549
|
+
if (!c && Oe !== void 0) {
|
|
550
550
|
let t = `${u}/additionalItems`;
|
|
551
551
|
for (; r < n; r++) {
|
|
552
|
-
let n =
|
|
553
|
-
d[r] = !0, n.valid || (c = o,
|
|
552
|
+
let n = h(e[r], Oe, i, a, o, s, `${l}/${r}`, t);
|
|
553
|
+
d[r] = !0, n.valid || (c = o, w.push({
|
|
554
554
|
instanceLocation: l,
|
|
555
555
|
keyword: "additionalItems",
|
|
556
556
|
keywordLocation: t,
|
|
@@ -559,49 +559,49 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
559
559
|
}
|
|
560
560
|
}
|
|
561
561
|
}
|
|
562
|
-
if (
|
|
563
|
-
if (n === 0 &&
|
|
562
|
+
if (_ !== void 0) {
|
|
563
|
+
if (n === 0 && v === void 0) w.push({
|
|
564
564
|
instanceLocation: l,
|
|
565
565
|
keyword: "contains",
|
|
566
566
|
keywordLocation: `${u}/contains`,
|
|
567
567
|
error: "Array is empty. It must contain at least one item matching the schema."
|
|
568
568
|
});
|
|
569
|
-
else if (
|
|
569
|
+
else if (v !== void 0 && n < v) w.push({
|
|
570
570
|
instanceLocation: l,
|
|
571
571
|
keyword: "minContains",
|
|
572
572
|
keywordLocation: `${u}/minContains`,
|
|
573
|
-
error: `Array has less items (${n}) than minContains (${
|
|
573
|
+
error: `Array has less items (${n}) than minContains (${v}).`
|
|
574
574
|
});
|
|
575
575
|
else {
|
|
576
|
-
let t = `${u}/contains`, r =
|
|
576
|
+
let t = `${u}/contains`, r = w.length, c = 0;
|
|
577
577
|
for (let r = 0; r < n; r++) {
|
|
578
|
-
let n =
|
|
579
|
-
n.valid ? (d[r] = !0, c++) :
|
|
578
|
+
let n = h(e[r], _, i, a, o, s, `${l}/${r}`, t);
|
|
579
|
+
n.valid ? (d[r] = !0, c++) : w.push(...n.errors);
|
|
580
580
|
}
|
|
581
|
-
c >= (
|
|
581
|
+
c >= (v || 0) && (w.length = r), v === void 0 && y === void 0 && c === 0 ? w.splice(r, 0, {
|
|
582
582
|
instanceLocation: l,
|
|
583
583
|
keyword: "contains",
|
|
584
584
|
keywordLocation: t,
|
|
585
585
|
error: "Array does not contain item matching schema."
|
|
586
|
-
}) :
|
|
586
|
+
}) : v !== void 0 && c < v ? w.push({
|
|
587
587
|
instanceLocation: l,
|
|
588
588
|
keyword: "minContains",
|
|
589
589
|
keywordLocation: `${u}/minContains`,
|
|
590
|
-
error: `Array must contain at least ${
|
|
591
|
-
}) :
|
|
590
|
+
error: `Array must contain at least ${v} items matching schema. Only ${c} items were found.`
|
|
591
|
+
}) : y !== void 0 && c > y && w.push({
|
|
592
592
|
instanceLocation: l,
|
|
593
593
|
keyword: "maxContains",
|
|
594
594
|
keywordLocation: `${u}/maxContains`,
|
|
595
|
-
error: `Array may contain at most ${
|
|
595
|
+
error: `Array may contain at most ${y} items matching schema. ${c} items were found.`
|
|
596
596
|
});
|
|
597
597
|
}
|
|
598
598
|
}
|
|
599
|
-
if (!c &&
|
|
599
|
+
if (!c && g !== void 0) {
|
|
600
600
|
let t = `${u}/unevaluatedItems`;
|
|
601
601
|
for (; r < n; r++) {
|
|
602
602
|
if (d[r]) continue;
|
|
603
|
-
let n =
|
|
604
|
-
d[r] = !0, n.valid ||
|
|
603
|
+
let n = h(e[r], g, i, a, o, s, `${l}/${r}`, t);
|
|
604
|
+
d[r] = !0, n.valid || w.push({
|
|
605
605
|
instanceLocation: l,
|
|
606
606
|
keyword: "unevaluatedItems",
|
|
607
607
|
keywordLocation: t,
|
|
@@ -609,12 +609,12 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
609
609
|
}, ...n.errors);
|
|
610
610
|
}
|
|
611
611
|
}
|
|
612
|
-
if (
|
|
612
|
+
if (ke) for (let r = 0; r < n; r++) {
|
|
613
613
|
let i = e[r], a = typeof i == "object" && !!i;
|
|
614
614
|
for (let o = 0; o < n; o++) {
|
|
615
615
|
if (r === o) continue;
|
|
616
616
|
let n = e[o];
|
|
617
|
-
(i === n || a && typeof n == "object" && n && t(i, n)) && (
|
|
617
|
+
(i === n || a && typeof n == "object" && n && t(i, n)) && (w.push({
|
|
618
618
|
instanceLocation: l,
|
|
619
619
|
keyword: "uniqueItems",
|
|
620
620
|
keywordLocation: `${u}/uniqueItems`,
|
|
@@ -623,77 +623,77 @@ function g(e, r, i = "2019-09", a = c(r), o = !0, s = null, l = "#", u = "#", d
|
|
|
623
623
|
}
|
|
624
624
|
}
|
|
625
625
|
} else if (p === "number") {
|
|
626
|
-
if (i === "4" ? (
|
|
626
|
+
if (i === "4" ? (S !== void 0 && (je === !0 && e <= S || e < S) && w.push({
|
|
627
627
|
instanceLocation: l,
|
|
628
628
|
keyword: "minimum",
|
|
629
629
|
keywordLocation: `${u}/minimum`,
|
|
630
|
-
error: `${e} is less than ${
|
|
631
|
-
}),
|
|
630
|
+
error: `${e} is less than ${je ? "or equal to " : ""} ${S}.`
|
|
631
|
+
}), Ae !== void 0 && (Me === !0 && e >= Ae || e > Ae) && w.push({
|
|
632
632
|
instanceLocation: l,
|
|
633
633
|
keyword: "maximum",
|
|
634
634
|
keywordLocation: `${u}/maximum`,
|
|
635
|
-
error: `${e} is greater than ${
|
|
636
|
-
})) : (
|
|
635
|
+
error: `${e} is greater than ${Me ? "or equal to " : ""} ${Ae}.`
|
|
636
|
+
})) : (S !== void 0 && e < S && w.push({
|
|
637
637
|
instanceLocation: l,
|
|
638
638
|
keyword: "minimum",
|
|
639
639
|
keywordLocation: `${u}/minimum`,
|
|
640
|
-
error: `${e} is less than ${
|
|
641
|
-
}),
|
|
640
|
+
error: `${e} is less than ${S}.`
|
|
641
|
+
}), Ae !== void 0 && e > Ae && w.push({
|
|
642
642
|
instanceLocation: l,
|
|
643
643
|
keyword: "maximum",
|
|
644
644
|
keywordLocation: `${u}/maximum`,
|
|
645
|
-
error: `${e} is greater than ${
|
|
646
|
-
}),
|
|
645
|
+
error: `${e} is greater than ${Ae}.`
|
|
646
|
+
}), je !== void 0 && e <= je && w.push({
|
|
647
647
|
instanceLocation: l,
|
|
648
648
|
keyword: "exclusiveMinimum",
|
|
649
649
|
keywordLocation: `${u}/exclusiveMinimum`,
|
|
650
|
-
error: `${e} is less than ${
|
|
651
|
-
}),
|
|
650
|
+
error: `${e} is less than ${je}.`
|
|
651
|
+
}), Me !== void 0 && e >= Me && w.push({
|
|
652
652
|
instanceLocation: l,
|
|
653
653
|
keyword: "exclusiveMaximum",
|
|
654
654
|
keywordLocation: `${u}/exclusiveMaximum`,
|
|
655
|
-
error: `${e} is greater than or equal to ${
|
|
656
|
-
})),
|
|
657
|
-
let t = e %
|
|
658
|
-
Math.abs(0 - t) >= 1.1920929e-7 && Math.abs(
|
|
655
|
+
error: `${e} is greater than or equal to ${Me}.`
|
|
656
|
+
})), Ne !== void 0) {
|
|
657
|
+
let t = e % Ne;
|
|
658
|
+
Math.abs(0 - t) >= 1.1920929e-7 && Math.abs(Ne - t) >= 1.1920929e-7 && w.push({
|
|
659
659
|
instanceLocation: l,
|
|
660
660
|
keyword: "multipleOf",
|
|
661
661
|
keywordLocation: `${u}/multipleOf`,
|
|
662
|
-
error: `${e} is not a multiple of ${
|
|
662
|
+
error: `${e} is not a multiple of ${Ne}.`
|
|
663
663
|
});
|
|
664
664
|
}
|
|
665
665
|
} else if (p === "string") {
|
|
666
|
-
let t =
|
|
667
|
-
|
|
666
|
+
let t = Pe === void 0 && Fe === void 0 ? 0 : xe(e);
|
|
667
|
+
Pe !== void 0 && t < Pe && w.push({
|
|
668
668
|
instanceLocation: l,
|
|
669
669
|
keyword: "minLength",
|
|
670
670
|
keywordLocation: `${u}/minLength`,
|
|
671
|
-
error: `String is too short (${t} < ${
|
|
672
|
-
}),
|
|
671
|
+
error: `String is too short (${t} < ${Pe}).`
|
|
672
|
+
}), Fe !== void 0 && t > Fe && w.push({
|
|
673
673
|
instanceLocation: l,
|
|
674
674
|
keyword: "maxLength",
|
|
675
675
|
keywordLocation: `${u}/maxLength`,
|
|
676
|
-
error: `String is too long (${t} > ${
|
|
677
|
-
}),
|
|
676
|
+
error: `String is too long (${t} > ${Fe}).`
|
|
677
|
+
}), Ie !== void 0 && !new RegExp(Ie, "u").test(e) && w.push({
|
|
678
678
|
instanceLocation: l,
|
|
679
679
|
keyword: "pattern",
|
|
680
680
|
keywordLocation: `${u}/pattern`,
|
|
681
681
|
error: "String does not match pattern."
|
|
682
|
-
}),
|
|
682
|
+
}), me !== void 0 && ue[me] && !ue[me](e) && w.push({
|
|
683
683
|
instanceLocation: l,
|
|
684
684
|
keyword: "format",
|
|
685
685
|
keywordLocation: `${u}/format`,
|
|
686
|
-
error: `String does not match format "${
|
|
686
|
+
error: `String does not match format "${me}".`
|
|
687
687
|
});
|
|
688
688
|
}
|
|
689
689
|
return {
|
|
690
|
-
valid:
|
|
691
|
-
errors:
|
|
690
|
+
valid: w.length === 0,
|
|
691
|
+
errors: w
|
|
692
692
|
};
|
|
693
693
|
}
|
|
694
694
|
//#endregion
|
|
695
695
|
//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/validator.js
|
|
696
|
-
var
|
|
696
|
+
var Se = class {
|
|
697
697
|
schema;
|
|
698
698
|
draft;
|
|
699
699
|
shortCircuit;
|
|
@@ -702,7 +702,7 @@ var xe = class {
|
|
|
702
702
|
this.schema = e, this.draft = t, this.shortCircuit = n, this.lookup = c(e);
|
|
703
703
|
}
|
|
704
704
|
validate(e) {
|
|
705
|
-
return
|
|
705
|
+
return h(e, this.schema, this.draft, this.lookup, this.shortCircuit);
|
|
706
706
|
}
|
|
707
707
|
addSchema(e, t) {
|
|
708
708
|
t && (e = {
|
|
@@ -710,105 +710,105 @@ var xe = class {
|
|
|
710
710
|
$id: t
|
|
711
711
|
}), c(e, this.lookup);
|
|
712
712
|
}
|
|
713
|
-
},
|
|
714
|
-
function
|
|
715
|
-
let e =
|
|
716
|
-
return
|
|
713
|
+
}, Ce = 0;
|
|
714
|
+
function we() {
|
|
715
|
+
let e = Ce;
|
|
716
|
+
return Ce += 1, e;
|
|
717
717
|
}
|
|
718
|
-
function
|
|
718
|
+
function Te(e) {
|
|
719
719
|
if (typeof e == "object" && e && !Object.isFrozen(e)) {
|
|
720
|
-
for (let t of Object.getOwnPropertyNames(e))
|
|
720
|
+
for (let t of Object.getOwnPropertyNames(e)) Te(Reflect.get(e, t));
|
|
721
721
|
Object.freeze(e);
|
|
722
722
|
}
|
|
723
723
|
return e;
|
|
724
724
|
}
|
|
725
|
-
function
|
|
725
|
+
function Ee(e, t) {
|
|
726
726
|
let n = {};
|
|
727
727
|
for (let r of t) r in e && (n[r] = e[r]);
|
|
728
728
|
return n;
|
|
729
729
|
}
|
|
730
|
-
function
|
|
730
|
+
function De(e) {
|
|
731
731
|
if (typeof e != "object" || !e) return e;
|
|
732
732
|
if (Array.isArray(e)) {
|
|
733
733
|
let t = [];
|
|
734
|
-
for (let [n, r] of e.entries()) t[n] =
|
|
734
|
+
for (let [n, r] of e.entries()) t[n] = De(r);
|
|
735
735
|
return t;
|
|
736
736
|
}
|
|
737
737
|
{
|
|
738
738
|
let t = {};
|
|
739
|
-
for (let n in e) t[n] =
|
|
739
|
+
for (let n in e) t[n] = De(e[n]);
|
|
740
740
|
return t;
|
|
741
741
|
}
|
|
742
742
|
}
|
|
743
|
-
function
|
|
743
|
+
function Oe(e, t) {
|
|
744
744
|
if (e === t) return !0;
|
|
745
745
|
if (typeof e != "object" || !e || typeof e != typeof t) return !1;
|
|
746
746
|
if (Array.isArray(e)) {
|
|
747
747
|
if (!Array.isArray(t) || e.length !== t.length) return !1;
|
|
748
|
-
for (let [n, r] of e.entries()) if (!
|
|
748
|
+
for (let [n, r] of e.entries()) if (!Oe(r, t[n])) return !1;
|
|
749
749
|
} else {
|
|
750
750
|
if (Array.isArray(t)) return !1;
|
|
751
|
-
for (let n in e) if (!(n in t) || !
|
|
751
|
+
for (let n in e) if (!(n in t) || !Oe(e[n], t[n])) return !1;
|
|
752
752
|
for (let n in t) if (!(n in e)) return !1;
|
|
753
753
|
}
|
|
754
754
|
return !0;
|
|
755
755
|
}
|
|
756
756
|
//#endregion
|
|
757
757
|
//#region src/json-schema-subset/expression/result.ts
|
|
758
|
-
var
|
|
758
|
+
var g = Object.freeze({
|
|
759
759
|
Equals: 0,
|
|
760
760
|
Containing: 1,
|
|
761
761
|
ContainedBy: 2,
|
|
762
762
|
Rejection: 3,
|
|
763
763
|
Intersection: 4
|
|
764
|
-
}),
|
|
765
|
-
[
|
|
766
|
-
[
|
|
767
|
-
[
|
|
768
|
-
[
|
|
769
|
-
[
|
|
770
|
-
]),
|
|
764
|
+
}), _ = Fe(g.Equals), v = Fe(g.Containing), y = Fe(g.ContainedBy), b = Fe(g.Rejection), x = Fe(g.Intersection), ke = Te([
|
|
765
|
+
[g.Equals, _],
|
|
766
|
+
[g.Containing, v],
|
|
767
|
+
[g.ContainedBy, y],
|
|
768
|
+
[g.Rejection, b],
|
|
769
|
+
[g.Intersection, x]
|
|
770
|
+
]), S = (() => {
|
|
771
771
|
let e = 0;
|
|
772
|
-
for (let [t, n] of
|
|
772
|
+
for (let [t, n] of ke) e |= n;
|
|
773
773
|
return e;
|
|
774
774
|
})();
|
|
775
|
-
function ke(e) {
|
|
776
|
-
return !!(e & v);
|
|
777
|
-
}
|
|
778
775
|
function Ae(e) {
|
|
779
|
-
return !!(e &
|
|
776
|
+
return !!(e & _);
|
|
780
777
|
}
|
|
781
778
|
function je(e) {
|
|
782
|
-
return !!(e &
|
|
779
|
+
return !!(e & v);
|
|
783
780
|
}
|
|
784
781
|
function Me(e) {
|
|
785
|
-
return !!(e &
|
|
782
|
+
return !!(e & y);
|
|
786
783
|
}
|
|
787
784
|
function Ne(e) {
|
|
788
|
-
return !!(e &
|
|
785
|
+
return !!(e & b);
|
|
789
786
|
}
|
|
790
787
|
function Pe(e) {
|
|
788
|
+
return !!(e & x);
|
|
789
|
+
}
|
|
790
|
+
function Fe(e) {
|
|
791
791
|
return 1 << e;
|
|
792
792
|
}
|
|
793
793
|
//#endregion
|
|
794
794
|
//#region src/json-schema-subset/expression/combination.ts
|
|
795
|
-
function
|
|
796
|
-
let t = 0, n = 0, r = { push: (r) => (t = n === 0 ? r :
|
|
795
|
+
function Ie(e) {
|
|
796
|
+
let t = 0, n = 0, r = { push: (r) => (t = n === 0 ? r : Le(t, r, e), n += 1, t) };
|
|
797
797
|
return Object.defineProperties(r, {
|
|
798
798
|
result: { get: () => t },
|
|
799
799
|
count: { get: () => n }
|
|
800
800
|
}), r;
|
|
801
801
|
}
|
|
802
|
-
function
|
|
802
|
+
function Le(e, t, n) {
|
|
803
803
|
let r = 0;
|
|
804
|
-
for (let [i, a] of
|
|
805
|
-
for (let [e, a] of
|
|
804
|
+
for (let [i, a] of ke) if (a & e) {
|
|
805
|
+
for (let [e, a] of ke) if (a & t && (r |= n(i, e), r === S)) return r;
|
|
806
806
|
}
|
|
807
807
|
return r;
|
|
808
808
|
}
|
|
809
809
|
//#endregion
|
|
810
810
|
//#region src/json-schema-subset/expression/calculator.ts
|
|
811
|
-
var
|
|
811
|
+
var C = Object.freeze({
|
|
812
812
|
Save: 0,
|
|
813
813
|
OneOf: 1,
|
|
814
814
|
AllOf: 2,
|
|
@@ -816,289 +816,289 @@ var w = Object.freeze({
|
|
|
816
816
|
Not: 4,
|
|
817
817
|
Swap: 5
|
|
818
818
|
});
|
|
819
|
-
function
|
|
819
|
+
function w(e, t) {
|
|
820
820
|
switch (e) {
|
|
821
|
-
case
|
|
822
|
-
case
|
|
823
|
-
case
|
|
824
|
-
case
|
|
825
|
-
case
|
|
826
|
-
case
|
|
821
|
+
case C.Save: return t[0];
|
|
822
|
+
case C.OneOf: return ze(t);
|
|
823
|
+
case C.AllOf:
|
|
824
|
+
case C.AnyOf: return Be(e, t);
|
|
825
|
+
case C.Not:
|
|
826
|
+
case C.Swap: return Ve(e, t[0]);
|
|
827
827
|
}
|
|
828
828
|
}
|
|
829
|
-
function Le(e) {
|
|
830
|
-
return Be(w.Swap, e);
|
|
831
|
-
}
|
|
832
829
|
function Re(e) {
|
|
830
|
+
return Ve(C.Swap, e);
|
|
831
|
+
}
|
|
832
|
+
function ze(e) {
|
|
833
833
|
if (e.length === 1) return e[0];
|
|
834
|
-
let t =
|
|
834
|
+
let t = Be(C.AnyOf, e), n = [];
|
|
835
835
|
for (let t = 0; t < e.length; ++t) for (let r = t + 1; r < e.length; ++r) {
|
|
836
|
-
let i = e[t], a = e[r], o =
|
|
836
|
+
let i = e[t], a = e[r], o = Be(C.AllOf, [i, a]);
|
|
837
837
|
n.push(o);
|
|
838
838
|
}
|
|
839
|
-
let r =
|
|
840
|
-
return
|
|
839
|
+
let r = Be(C.AnyOf, n), i = Ve(C.Not, r);
|
|
840
|
+
return Be(C.AllOf, [t, i]);
|
|
841
841
|
}
|
|
842
|
-
function
|
|
842
|
+
function Be(e, t) {
|
|
843
843
|
if (t.length < 0) throw Error("invalid expressions: empty array");
|
|
844
844
|
let n;
|
|
845
845
|
switch (e) {
|
|
846
|
-
case
|
|
847
|
-
n =
|
|
846
|
+
case C.AllOf:
|
|
847
|
+
n = Ie(He);
|
|
848
848
|
break;
|
|
849
|
-
case
|
|
850
|
-
n =
|
|
849
|
+
case C.AnyOf:
|
|
850
|
+
n = Ie(Ue);
|
|
851
851
|
break;
|
|
852
852
|
default: throw Error(`invalid operator ${e}`);
|
|
853
853
|
}
|
|
854
854
|
for (let e of t) n.push(e);
|
|
855
855
|
return n.result;
|
|
856
856
|
}
|
|
857
|
-
function
|
|
857
|
+
function Ve(e, t) {
|
|
858
858
|
let n, r = 0;
|
|
859
859
|
switch (e) {
|
|
860
|
-
case
|
|
861
|
-
n = Ue;
|
|
862
|
-
break;
|
|
863
|
-
case w.Swap:
|
|
860
|
+
case C.Not:
|
|
864
861
|
n = We;
|
|
865
862
|
break;
|
|
863
|
+
case C.Swap:
|
|
864
|
+
n = Ge;
|
|
865
|
+
break;
|
|
866
866
|
default: throw Error(`invalid operator ${e}`);
|
|
867
867
|
}
|
|
868
|
-
for (let [e, i] of
|
|
868
|
+
for (let [e, i] of ke) i & t && (r |= n(e));
|
|
869
869
|
return r;
|
|
870
870
|
}
|
|
871
|
-
function
|
|
871
|
+
function He(e, t) {
|
|
872
872
|
let n = 0;
|
|
873
873
|
switch (e) {
|
|
874
|
-
case
|
|
874
|
+
case g.Equals:
|
|
875
875
|
switch (t) {
|
|
876
|
-
case
|
|
877
|
-
n =
|
|
876
|
+
case g.Equals:
|
|
877
|
+
n = _;
|
|
878
878
|
break;
|
|
879
|
-
case
|
|
880
|
-
n =
|
|
879
|
+
case g.Containing:
|
|
880
|
+
n = _;
|
|
881
881
|
break;
|
|
882
|
-
case
|
|
883
|
-
n =
|
|
882
|
+
case g.ContainedBy:
|
|
883
|
+
n = y;
|
|
884
884
|
break;
|
|
885
|
-
case
|
|
885
|
+
case g.Rejection:
|
|
886
886
|
n = 0;
|
|
887
887
|
break;
|
|
888
|
-
case
|
|
888
|
+
case g.Intersection: n = y;
|
|
889
889
|
}
|
|
890
890
|
break;
|
|
891
|
-
case
|
|
891
|
+
case g.Containing:
|
|
892
892
|
switch (t) {
|
|
893
|
-
case
|
|
894
|
-
n =
|
|
893
|
+
case g.Equals:
|
|
894
|
+
n = _;
|
|
895
895
|
break;
|
|
896
|
-
case
|
|
897
|
-
n =
|
|
896
|
+
case g.Containing:
|
|
897
|
+
n = _ | v;
|
|
898
898
|
break;
|
|
899
|
-
case
|
|
900
|
-
n =
|
|
899
|
+
case g.ContainedBy:
|
|
900
|
+
n = y;
|
|
901
901
|
break;
|
|
902
|
-
case
|
|
903
|
-
n =
|
|
902
|
+
case g.Rejection:
|
|
903
|
+
n = b;
|
|
904
904
|
break;
|
|
905
|
-
case
|
|
905
|
+
case g.Intersection: n = x | y;
|
|
906
906
|
}
|
|
907
907
|
break;
|
|
908
|
-
case
|
|
908
|
+
case g.ContainedBy:
|
|
909
909
|
switch (t) {
|
|
910
|
-
case
|
|
911
|
-
n =
|
|
910
|
+
case g.Equals:
|
|
911
|
+
n = y;
|
|
912
912
|
break;
|
|
913
|
-
case
|
|
914
|
-
n =
|
|
913
|
+
case g.Containing:
|
|
914
|
+
n = y;
|
|
915
915
|
break;
|
|
916
|
-
case
|
|
917
|
-
n =
|
|
916
|
+
case g.ContainedBy:
|
|
917
|
+
n = y;
|
|
918
918
|
break;
|
|
919
|
-
case
|
|
919
|
+
case g.Rejection:
|
|
920
920
|
n = 0;
|
|
921
921
|
break;
|
|
922
|
-
case
|
|
922
|
+
case g.Intersection: n = y;
|
|
923
923
|
}
|
|
924
924
|
break;
|
|
925
|
-
case
|
|
925
|
+
case g.Rejection:
|
|
926
926
|
switch (t) {
|
|
927
|
-
case
|
|
927
|
+
case g.Equals:
|
|
928
928
|
n = 0;
|
|
929
929
|
break;
|
|
930
|
-
case
|
|
931
|
-
n =
|
|
930
|
+
case g.Containing:
|
|
931
|
+
n = b;
|
|
932
932
|
break;
|
|
933
|
-
case
|
|
933
|
+
case g.ContainedBy:
|
|
934
934
|
n = 0;
|
|
935
935
|
break;
|
|
936
|
-
case
|
|
937
|
-
n =
|
|
936
|
+
case g.Rejection:
|
|
937
|
+
n = b;
|
|
938
938
|
break;
|
|
939
|
-
case
|
|
939
|
+
case g.Intersection: n = b;
|
|
940
940
|
}
|
|
941
941
|
break;
|
|
942
|
-
case
|
|
943
|
-
case
|
|
944
|
-
n =
|
|
942
|
+
case g.Intersection: switch (t) {
|
|
943
|
+
case g.Equals:
|
|
944
|
+
n = y;
|
|
945
945
|
break;
|
|
946
|
-
case
|
|
947
|
-
n =
|
|
946
|
+
case g.Containing:
|
|
947
|
+
n = x | y;
|
|
948
948
|
break;
|
|
949
|
-
case
|
|
950
|
-
n =
|
|
949
|
+
case g.ContainedBy:
|
|
950
|
+
n = y;
|
|
951
951
|
break;
|
|
952
|
-
case
|
|
953
|
-
n =
|
|
952
|
+
case g.Rejection:
|
|
953
|
+
n = b;
|
|
954
954
|
break;
|
|
955
|
-
case
|
|
955
|
+
case g.Intersection: n = y | b | x;
|
|
956
956
|
}
|
|
957
957
|
}
|
|
958
958
|
return n;
|
|
959
959
|
}
|
|
960
|
-
function
|
|
960
|
+
function Ue(e, t) {
|
|
961
961
|
let n = 0;
|
|
962
962
|
switch (e) {
|
|
963
|
-
case
|
|
963
|
+
case g.Equals:
|
|
964
964
|
switch (t) {
|
|
965
|
-
case
|
|
965
|
+
case g.Equals:
|
|
966
|
+
n = _;
|
|
967
|
+
break;
|
|
968
|
+
case g.Containing:
|
|
966
969
|
n = v;
|
|
967
970
|
break;
|
|
968
|
-
case
|
|
969
|
-
n =
|
|
971
|
+
case g.ContainedBy:
|
|
972
|
+
n = _;
|
|
970
973
|
break;
|
|
971
|
-
case
|
|
974
|
+
case g.Rejection:
|
|
972
975
|
n = v;
|
|
973
976
|
break;
|
|
974
|
-
case
|
|
975
|
-
n = y;
|
|
976
|
-
break;
|
|
977
|
-
case _.Intersection: n = y;
|
|
977
|
+
case g.Intersection: n = v;
|
|
978
978
|
}
|
|
979
979
|
break;
|
|
980
|
-
case
|
|
980
|
+
case g.Containing:
|
|
981
981
|
switch (t) {
|
|
982
|
-
case
|
|
983
|
-
n =
|
|
982
|
+
case g.Equals:
|
|
983
|
+
n = v;
|
|
984
984
|
break;
|
|
985
|
-
case
|
|
986
|
-
n =
|
|
985
|
+
case g.Containing:
|
|
986
|
+
n = v;
|
|
987
987
|
break;
|
|
988
|
-
case
|
|
989
|
-
n =
|
|
988
|
+
case g.ContainedBy:
|
|
989
|
+
n = v;
|
|
990
990
|
break;
|
|
991
|
-
case
|
|
992
|
-
n =
|
|
991
|
+
case g.Rejection:
|
|
992
|
+
n = v;
|
|
993
993
|
break;
|
|
994
|
-
case
|
|
994
|
+
case g.Intersection: n = v;
|
|
995
995
|
}
|
|
996
996
|
break;
|
|
997
|
-
case
|
|
997
|
+
case g.ContainedBy:
|
|
998
998
|
switch (t) {
|
|
999
|
-
case
|
|
1000
|
-
n =
|
|
999
|
+
case g.Equals:
|
|
1000
|
+
n = _;
|
|
1001
1001
|
break;
|
|
1002
|
-
case
|
|
1003
|
-
n =
|
|
1002
|
+
case g.Containing:
|
|
1003
|
+
n = v;
|
|
1004
1004
|
break;
|
|
1005
|
-
case
|
|
1006
|
-
n =
|
|
1005
|
+
case g.ContainedBy:
|
|
1006
|
+
n = _ | y;
|
|
1007
1007
|
break;
|
|
1008
|
-
case
|
|
1009
|
-
n =
|
|
1008
|
+
case g.Rejection:
|
|
1009
|
+
n = x;
|
|
1010
1010
|
break;
|
|
1011
|
-
case
|
|
1011
|
+
case g.Intersection: n = v | x;
|
|
1012
1012
|
}
|
|
1013
1013
|
break;
|
|
1014
|
-
case
|
|
1014
|
+
case g.Rejection:
|
|
1015
1015
|
switch (t) {
|
|
1016
|
-
case
|
|
1017
|
-
n =
|
|
1018
|
-
break;
|
|
1019
|
-
case _.Containing:
|
|
1020
|
-
n = y;
|
|
1016
|
+
case g.Equals:
|
|
1017
|
+
n = v;
|
|
1021
1018
|
break;
|
|
1022
|
-
case
|
|
1023
|
-
n =
|
|
1019
|
+
case g.Containing:
|
|
1020
|
+
n = v;
|
|
1024
1021
|
break;
|
|
1025
|
-
case
|
|
1022
|
+
case g.ContainedBy:
|
|
1026
1023
|
n = x;
|
|
1027
1024
|
break;
|
|
1028
|
-
case
|
|
1025
|
+
case g.Rejection:
|
|
1026
|
+
n = b;
|
|
1027
|
+
break;
|
|
1028
|
+
case g.Intersection: n = x;
|
|
1029
1029
|
}
|
|
1030
1030
|
break;
|
|
1031
|
-
case
|
|
1032
|
-
case
|
|
1033
|
-
n =
|
|
1031
|
+
case g.Intersection: switch (t) {
|
|
1032
|
+
case g.Equals:
|
|
1033
|
+
n = v;
|
|
1034
1034
|
break;
|
|
1035
|
-
case
|
|
1036
|
-
n =
|
|
1035
|
+
case g.Containing:
|
|
1036
|
+
n = v;
|
|
1037
1037
|
break;
|
|
1038
|
-
case
|
|
1039
|
-
n =
|
|
1038
|
+
case g.ContainedBy:
|
|
1039
|
+
n = v | x;
|
|
1040
1040
|
break;
|
|
1041
|
-
case
|
|
1042
|
-
n =
|
|
1041
|
+
case g.Rejection:
|
|
1042
|
+
n = x;
|
|
1043
1043
|
break;
|
|
1044
|
-
case
|
|
1044
|
+
case g.Intersection: n = v | x;
|
|
1045
1045
|
}
|
|
1046
1046
|
}
|
|
1047
1047
|
return n;
|
|
1048
1048
|
}
|
|
1049
|
-
function
|
|
1049
|
+
function We(e) {
|
|
1050
1050
|
let t = 0;
|
|
1051
1051
|
switch (e) {
|
|
1052
|
-
case
|
|
1053
|
-
t =
|
|
1052
|
+
case g.Equals:
|
|
1053
|
+
t = b;
|
|
1054
1054
|
break;
|
|
1055
|
-
case
|
|
1056
|
-
t =
|
|
1055
|
+
case g.Containing:
|
|
1056
|
+
t = b;
|
|
1057
1057
|
break;
|
|
1058
|
-
case
|
|
1059
|
-
t =
|
|
1058
|
+
case g.ContainedBy:
|
|
1059
|
+
t = x;
|
|
1060
1060
|
break;
|
|
1061
|
-
case
|
|
1062
|
-
t =
|
|
1061
|
+
case g.Rejection:
|
|
1062
|
+
t = _ | v;
|
|
1063
1063
|
break;
|
|
1064
|
-
case
|
|
1064
|
+
case g.Intersection: t = y | x;
|
|
1065
1065
|
}
|
|
1066
1066
|
return t;
|
|
1067
1067
|
}
|
|
1068
|
-
function
|
|
1068
|
+
function Ge(e) {
|
|
1069
1069
|
let t = 0;
|
|
1070
1070
|
switch (e) {
|
|
1071
|
-
case
|
|
1072
|
-
t =
|
|
1073
|
-
break;
|
|
1074
|
-
case _.Containing:
|
|
1075
|
-
t = b;
|
|
1071
|
+
case g.Equals:
|
|
1072
|
+
t = _;
|
|
1076
1073
|
break;
|
|
1077
|
-
case
|
|
1074
|
+
case g.Containing:
|
|
1078
1075
|
t = y;
|
|
1079
1076
|
break;
|
|
1080
|
-
case
|
|
1081
|
-
t =
|
|
1077
|
+
case g.ContainedBy:
|
|
1078
|
+
t = v;
|
|
1079
|
+
break;
|
|
1080
|
+
case g.Rejection:
|
|
1081
|
+
t = b;
|
|
1082
1082
|
break;
|
|
1083
|
-
case
|
|
1083
|
+
case g.Intersection: t = x;
|
|
1084
1084
|
}
|
|
1085
1085
|
return t;
|
|
1086
1086
|
}
|
|
1087
1087
|
//#endregion
|
|
1088
1088
|
//#region src/json-schema-subset/expression/types.ts
|
|
1089
|
-
var
|
|
1089
|
+
var Ke = Object.freeze({
|
|
1090
1090
|
Leaf: 0,
|
|
1091
1091
|
Not: 1,
|
|
1092
1092
|
AllOf: 2,
|
|
1093
1093
|
AnyOf: 3,
|
|
1094
1094
|
OneOf: 4
|
|
1095
|
-
}),
|
|
1095
|
+
}), qe = (e) => (t, n) => {
|
|
1096
1096
|
let r = {
|
|
1097
1097
|
parent: null,
|
|
1098
1098
|
swapped: !1,
|
|
1099
1099
|
expressions: null,
|
|
1100
1100
|
calculation: {
|
|
1101
|
-
operator:
|
|
1101
|
+
operator: C.Save,
|
|
1102
1102
|
results: [0],
|
|
1103
1103
|
willSwap: !1,
|
|
1104
1104
|
count: 0
|
|
@@ -1117,10 +1117,10 @@ var Ge = Object.freeze({
|
|
|
1117
1117
|
for (; a.length > 0;) c(a.pop());
|
|
1118
1118
|
}
|
|
1119
1119
|
function o(t) {
|
|
1120
|
-
let n =
|
|
1120
|
+
let n = _, [r, o] = t.expressions;
|
|
1121
1121
|
if (!e.equals(r, o)) {
|
|
1122
1122
|
let a = e.describe(r);
|
|
1123
|
-
if (a.kind !==
|
|
1123
|
+
if (a.kind !== Ke.Leaf) {
|
|
1124
1124
|
let [e, n] = s(a, !1);
|
|
1125
1125
|
t.expressions = null, t.calculation = e;
|
|
1126
1126
|
for (let [e, r] of n.entries()) i.push({
|
|
@@ -1135,7 +1135,7 @@ var Ge = Object.freeze({
|
|
|
1135
1135
|
return;
|
|
1136
1136
|
}
|
|
1137
1137
|
let c = e.describe(o);
|
|
1138
|
-
if (c.kind !==
|
|
1138
|
+
if (c.kind !== Ke.Leaf) {
|
|
1139
1139
|
let [e, n] = s(c, !0);
|
|
1140
1140
|
t.expressions = null, t.calculation = e;
|
|
1141
1141
|
for (let [e, a] of n.entries()) i.push({
|
|
@@ -1152,26 +1152,26 @@ var Ge = Object.freeze({
|
|
|
1152
1152
|
if (n = e.calculate(r, o), e.observeCalculation?.(r, o, n, t.swapped), n === 0) throw Error("cannot response expression as none");
|
|
1153
1153
|
}
|
|
1154
1154
|
t.expressions = null, t.calculation = {
|
|
1155
|
-
operator:
|
|
1155
|
+
operator: C.Save,
|
|
1156
1156
|
results: [n],
|
|
1157
1157
|
willSwap: !1,
|
|
1158
1158
|
count: 0
|
|
1159
1159
|
}, a.push(t);
|
|
1160
1160
|
}
|
|
1161
1161
|
function s(e, t) {
|
|
1162
|
-
let n =
|
|
1162
|
+
let n = C.Save, r;
|
|
1163
1163
|
switch (e.kind) {
|
|
1164
|
-
case
|
|
1165
|
-
n =
|
|
1164
|
+
case Ke.Not:
|
|
1165
|
+
n = C.Not, r = [e.expression];
|
|
1166
1166
|
break;
|
|
1167
|
-
case
|
|
1168
|
-
n =
|
|
1167
|
+
case Ke.AllOf:
|
|
1168
|
+
n = C.AllOf, r = [...e.expressions];
|
|
1169
1169
|
break;
|
|
1170
|
-
case
|
|
1171
|
-
n =
|
|
1170
|
+
case Ke.AnyOf:
|
|
1171
|
+
n = C.AnyOf, r = [...e.expressions];
|
|
1172
1172
|
break;
|
|
1173
|
-
case
|
|
1174
|
-
n =
|
|
1173
|
+
case Ke.OneOf:
|
|
1174
|
+
n = C.OneOf, r = [...e.expressions];
|
|
1175
1175
|
break;
|
|
1176
1176
|
default: throw Error(`invalid kind ${e.kind}`);
|
|
1177
1177
|
}
|
|
@@ -1183,8 +1183,8 @@ var Ge = Object.freeze({
|
|
|
1183
1183
|
}, r];
|
|
1184
1184
|
}
|
|
1185
1185
|
function c(e) {
|
|
1186
|
-
let t = e.calculation, n = e.parent, r =
|
|
1187
|
-
if (r === 0 && (r =
|
|
1186
|
+
let t = e.calculation, n = e.parent, r = w(t.operator, t.results);
|
|
1187
|
+
if (r === 0 && (r = y), t.willSwap && (r = Re(r)), n) {
|
|
1188
1188
|
let e = n.node.calculation, t = e.results;
|
|
1189
1189
|
t[n.index] = r, e.count += 1, e.count >= t.length && a.push(n.node);
|
|
1190
1190
|
}
|
|
@@ -1192,79 +1192,79 @@ var Ge = Object.freeze({
|
|
|
1192
1192
|
let l = r.calculation.results[0];
|
|
1193
1193
|
if (l === 0) throw Error("cannot find result of root");
|
|
1194
1194
|
return l;
|
|
1195
|
-
},
|
|
1195
|
+
}, Je = class extends Error {
|
|
1196
1196
|
constructor(e = []) {
|
|
1197
|
-
super(
|
|
1197
|
+
super(Ze(e)), this.name = "SchemaError", this.items = e;
|
|
1198
1198
|
}
|
|
1199
|
-
},
|
|
1199
|
+
}, Ye = Object.freeze({
|
|
1200
1200
|
Compiled: 0,
|
|
1201
1201
|
External: 1
|
|
1202
1202
|
});
|
|
1203
|
-
function
|
|
1203
|
+
function Xe(e) {
|
|
1204
1204
|
switch (e.kind) {
|
|
1205
|
-
case
|
|
1205
|
+
case Ye.Compiled: {
|
|
1206
1206
|
let { message: t, path: n } = e;
|
|
1207
1207
|
return `${t} (at ${n.length > 0 ? n.join(".") : "$root"})`;
|
|
1208
1208
|
}
|
|
1209
|
-
case
|
|
1209
|
+
case Ye.External: return String(e.error);
|
|
1210
1210
|
}
|
|
1211
1211
|
}
|
|
1212
|
-
function
|
|
1212
|
+
function Ze(e) {
|
|
1213
1213
|
switch (e.length) {
|
|
1214
1214
|
case 0: return "without any items";
|
|
1215
|
-
case 1: return
|
|
1216
|
-
default: return `${
|
|
1215
|
+
case 1: return Xe(e[0]);
|
|
1216
|
+
default: return `${Xe(e[0])} ... omit the rest ${e.length - 1} items`;
|
|
1217
1217
|
}
|
|
1218
1218
|
}
|
|
1219
1219
|
//#endregion
|
|
1220
1220
|
//#region src/json-schema-subset/compiler/common.ts
|
|
1221
|
-
var
|
|
1222
|
-
function Qe(e) {
|
|
1223
|
-
return Ze.has(e);
|
|
1224
|
-
}
|
|
1221
|
+
var Qe = /* @__PURE__ */ new Set(/* @__PURE__ */ "type.enum.const.multipleOf.maximum.exclusiveMaximum.minimum.exclusiveMinimum.maxLength.minLength.pattern.items.additionalItems.maxItems.minItems.uniqueItems.contains.maxProperties.minProperties.required.properties.patternProperties.additionalProperties.dependencies.propertyNames.if.then.else.allOf.anyOf.oneOf.not.format.contentMediaType.contentEncoding.definitions".split("."));
|
|
1225
1222
|
function $e(e) {
|
|
1226
|
-
|
|
1223
|
+
return Qe.has(e);
|
|
1224
|
+
}
|
|
1225
|
+
function et(e) {
|
|
1226
|
+
for (let t in e) if ($e(t)) return !1;
|
|
1227
1227
|
return !0;
|
|
1228
1228
|
}
|
|
1229
|
-
function
|
|
1229
|
+
function tt(e, ...t) {
|
|
1230
1230
|
return {
|
|
1231
1231
|
...e,
|
|
1232
1232
|
path: [...e.path, ...t]
|
|
1233
1233
|
};
|
|
1234
1234
|
}
|
|
1235
|
-
function
|
|
1235
|
+
function nt(e) {
|
|
1236
1236
|
if (typeof e == "boolean") throw Error("JSONSchema7Definition cannot be boolean");
|
|
1237
1237
|
return e;
|
|
1238
1238
|
}
|
|
1239
|
-
function
|
|
1240
|
-
t.push(
|
|
1239
|
+
function rt({ path: e, errors: t }, n, ...r) {
|
|
1240
|
+
t.push(it(e, r, n));
|
|
1241
1241
|
}
|
|
1242
|
-
function
|
|
1243
|
-
t.push(
|
|
1242
|
+
function T({ path: e, warns: t }, n, ...r) {
|
|
1243
|
+
t.push(it(e, r, n));
|
|
1244
1244
|
}
|
|
1245
|
-
function
|
|
1245
|
+
function it(e, t, n) {
|
|
1246
1246
|
return {
|
|
1247
|
-
kind:
|
|
1247
|
+
kind: Ye.Compiled,
|
|
1248
1248
|
message: n,
|
|
1249
1249
|
path: [...e, ...t]
|
|
1250
1250
|
};
|
|
1251
1251
|
}
|
|
1252
1252
|
//#endregion
|
|
1253
1253
|
//#region src/json-schema-subset/compiler/utils.ts
|
|
1254
|
-
function
|
|
1254
|
+
function at(e) {
|
|
1255
1255
|
for (let t in e) {
|
|
1256
1256
|
let n = e[t];
|
|
1257
|
-
n === void 0 ? delete e[t] : n && typeof n == "object" && (Array.isArray(n) ? n.length === 0 && delete e[t] :
|
|
1257
|
+
n === void 0 ? delete e[t] : n && typeof n == "object" && (Array.isArray(n) ? n.length === 0 && delete e[t] : ot(n) && delete e[t]);
|
|
1258
1258
|
}
|
|
1259
1259
|
return e;
|
|
1260
1260
|
}
|
|
1261
|
-
function
|
|
1261
|
+
function ot(e) {
|
|
1262
1262
|
for (let t in e) return !1;
|
|
1263
1263
|
return !0;
|
|
1264
1264
|
}
|
|
1265
1265
|
//#endregion
|
|
1266
1266
|
//#region src/json-schema-subset/compiler/wrapper.ts
|
|
1267
|
-
var
|
|
1267
|
+
var st = Symbol("compiledId"), ct = Symbol("compiledKind"), lt = Symbol("compiledPath"), ut = Symbol("validatorLoader"), E = Object.freeze({
|
|
1268
1268
|
Extends: 0,
|
|
1269
1269
|
Never: 1,
|
|
1270
1270
|
Any: 2,
|
|
@@ -1277,62 +1277,62 @@ var ot = Symbol("compiledId"), st = Symbol("compiledKind"), ct = Symbol("compile
|
|
|
1277
1277
|
Not: 9,
|
|
1278
1278
|
Combination: 10,
|
|
1279
1279
|
EnumOrConst: 11
|
|
1280
|
-
}),
|
|
1280
|
+
}), dt = Te(yt(E.Any, we(), {}, () => () => !0)), ft = Te(yt(E.Never, we(), {
|
|
1281
1281
|
type: "string",
|
|
1282
1282
|
maxLength: 0,
|
|
1283
1283
|
minLength: 1
|
|
1284
1284
|
}, () => () => !1));
|
|
1285
|
-
function ft(e) {
|
|
1286
|
-
return typeof e != "object" || !e ? !1 : ot in e;
|
|
1287
|
-
}
|
|
1288
1285
|
function pt(e) {
|
|
1289
|
-
return typeof e != "object" || !e ? !1 :
|
|
1290
|
-
}
|
|
1291
|
-
function O(e) {
|
|
1292
|
-
return pt(e) ? e[st] : D.Extends;
|
|
1286
|
+
return typeof e != "object" || !e ? !1 : st in e;
|
|
1293
1287
|
}
|
|
1294
1288
|
function mt(e) {
|
|
1295
|
-
return
|
|
1289
|
+
return typeof e != "object" || !e ? !1 : st in e && ct in e;
|
|
1290
|
+
}
|
|
1291
|
+
function D(e) {
|
|
1292
|
+
return mt(e) ? e[ct] : E.Extends;
|
|
1296
1293
|
}
|
|
1297
1294
|
function ht(e) {
|
|
1298
|
-
return pt(e) ? e[
|
|
1295
|
+
return mt(e) || pt(e) ? e[st] : e.id;
|
|
1299
1296
|
}
|
|
1300
1297
|
function gt(e) {
|
|
1301
|
-
return
|
|
1302
|
-
|
|
1298
|
+
return mt(e) ? e[lt] : void 0;
|
|
1299
|
+
}
|
|
1300
|
+
function _t(e) {
|
|
1301
|
+
return typeof e != "object" || !e || Object.defineProperty(e, st, {
|
|
1302
|
+
value: we(),
|
|
1303
1303
|
configurable: !1,
|
|
1304
1304
|
writable: !1,
|
|
1305
1305
|
enumerable: !1
|
|
1306
1306
|
}), e;
|
|
1307
1307
|
}
|
|
1308
|
-
function
|
|
1309
|
-
return
|
|
1308
|
+
function O(e, t, n, r = []) {
|
|
1309
|
+
return yt(e, we(), t, n && (() => n.compile(t)), r);
|
|
1310
1310
|
}
|
|
1311
|
-
function
|
|
1312
|
-
return
|
|
1311
|
+
function vt(e) {
|
|
1312
|
+
return yt(E.Never, we(), { ...e }, e[ut], e[lt]);
|
|
1313
1313
|
}
|
|
1314
|
-
function
|
|
1314
|
+
function yt(e, t, n, r, i = []) {
|
|
1315
1315
|
let a = null;
|
|
1316
1316
|
return Object.defineProperties(n, {
|
|
1317
|
-
[
|
|
1317
|
+
[ct]: {
|
|
1318
1318
|
value: e,
|
|
1319
1319
|
configurable: !1,
|
|
1320
1320
|
writable: !1,
|
|
1321
1321
|
enumerable: !1
|
|
1322
1322
|
},
|
|
1323
|
-
[
|
|
1323
|
+
[st]: {
|
|
1324
1324
|
value: t,
|
|
1325
1325
|
configurable: !1,
|
|
1326
1326
|
writable: !1,
|
|
1327
1327
|
enumerable: !1
|
|
1328
1328
|
},
|
|
1329
|
-
[
|
|
1329
|
+
[lt]: {
|
|
1330
1330
|
value: i,
|
|
1331
1331
|
configurable: !1,
|
|
1332
1332
|
writable: !1,
|
|
1333
1333
|
enumerable: !1
|
|
1334
1334
|
},
|
|
1335
|
-
[
|
|
1335
|
+
[ut]: {
|
|
1336
1336
|
value: r,
|
|
1337
1337
|
configurable: !1,
|
|
1338
1338
|
writable: !1,
|
|
@@ -1349,16 +1349,16 @@ function vt(e, t, n, r, i = []) {
|
|
|
1349
1349
|
}
|
|
1350
1350
|
//#endregion
|
|
1351
1351
|
//#region src/json-schema-subset/compiler/array.ts
|
|
1352
|
-
function
|
|
1353
|
-
let n =
|
|
1354
|
-
if (Array.isArray(n) ? s =
|
|
1352
|
+
function bt(e, t) {
|
|
1353
|
+
let n = xt(e, t), r = St(e, "maxItems", t), i = St(e, "minItems", t), a = Ct(e, t), o = t.uniqueItems, s;
|
|
1354
|
+
if (Array.isArray(n) ? s = wt(e, t) : t.additionalItems && T(e, "it is needless when items is not array", "additionalItems"), !n || !a || s === null) return null;
|
|
1355
1355
|
let c = !1, l = !1;
|
|
1356
1356
|
if (Array.isArray(n)) {
|
|
1357
|
-
r !== void 0 && r <= n.length && (n = n.splice(r), s =
|
|
1358
|
-
let t = n.findIndex((e) =>
|
|
1359
|
-
t !== -1 && (n = n.splice(t), s =
|
|
1360
|
-
} else
|
|
1361
|
-
return r !== void 0 && i !== void 0 && r < i && (l ||
|
|
1357
|
+
r !== void 0 && r <= n.length && (n = n.splice(r), s = Tt(s, e.delegate));
|
|
1358
|
+
let t = n.findIndex((e) => D(e) === E.Never);
|
|
1359
|
+
t !== -1 && (n = n.splice(t), s = Tt(s, e.delegate), r === void 0 && (r = n.length, l = !0)), i !== void 0 && n.length < i && (T(e, `length(${n.length}) of items if less than minItems(${i})`), c = !0), n.length === 0 && s && D(s) === E.Never && (c = !0);
|
|
1360
|
+
} else D(n) === E.Never && (c = !0);
|
|
1361
|
+
return r !== void 0 && i !== void 0 && r < i && (l || T(e, `maxItems(${r}) is less than minItems(${i})`), c = !0), O(c ? E.Never : E.Array, at({
|
|
1362
1362
|
type: "array",
|
|
1363
1363
|
items: n,
|
|
1364
1364
|
contains: a,
|
|
@@ -1368,12 +1368,12 @@ function yt(e, t) {
|
|
|
1368
1368
|
additionalItems: s
|
|
1369
1369
|
}), e.delegate, e.path);
|
|
1370
1370
|
}
|
|
1371
|
-
function
|
|
1372
|
-
if (!t) return
|
|
1371
|
+
function xt(e, { items: t }) {
|
|
1372
|
+
if (!t) return O(E.Any, {}, e.delegate, e.path);
|
|
1373
1373
|
if (Array.isArray(t)) {
|
|
1374
1374
|
let n = [], r = !1;
|
|
1375
1375
|
for (let [i, a] of t.entries()) {
|
|
1376
|
-
let t = A(
|
|
1376
|
+
let t = A(tt(e, "items", i), nt(a));
|
|
1377
1377
|
if (!t) {
|
|
1378
1378
|
r = !0;
|
|
1379
1379
|
continue;
|
|
@@ -1382,80 +1382,80 @@ function bt(e, { items: t }) {
|
|
|
1382
1382
|
}
|
|
1383
1383
|
return r ? null : n;
|
|
1384
1384
|
}
|
|
1385
|
-
return A(
|
|
1385
|
+
return A(tt(e, "items"), nt(t));
|
|
1386
1386
|
}
|
|
1387
|
-
function
|
|
1387
|
+
function St(e, t, n) {
|
|
1388
1388
|
let r = n[t];
|
|
1389
1389
|
if (r !== void 0) {
|
|
1390
1390
|
if (Number.isNaN(r)) {
|
|
1391
|
-
|
|
1391
|
+
T(e, "find NaN", t);
|
|
1392
1392
|
return;
|
|
1393
1393
|
}
|
|
1394
1394
|
if (r < 0) {
|
|
1395
|
-
|
|
1395
|
+
T(e, `find invalid number ${r}`, t);
|
|
1396
1396
|
return;
|
|
1397
1397
|
}
|
|
1398
1398
|
return r;
|
|
1399
1399
|
}
|
|
1400
1400
|
}
|
|
1401
|
-
function
|
|
1402
|
-
return t ? A(
|
|
1401
|
+
function Ct(e, { contains: t }) {
|
|
1402
|
+
return t ? A(tt(e, "contains"), nt(t)) : O(E.Any, {}, e.delegate, e.path);
|
|
1403
1403
|
}
|
|
1404
|
-
function
|
|
1404
|
+
function wt(e, { additionalItems: t }) {
|
|
1405
1405
|
switch (typeof t) {
|
|
1406
|
-
case "boolean": return t ?
|
|
1407
|
-
case "object": return A(
|
|
1408
|
-
default: return
|
|
1406
|
+
case "boolean": return t ? O(E.Any, {}, e.delegate, e.path) : !1;
|
|
1407
|
+
case "object": return A(tt(e, "additionalItems"), t);
|
|
1408
|
+
default: return O(E.Any, {}, e.delegate, e.path);
|
|
1409
1409
|
}
|
|
1410
1410
|
}
|
|
1411
|
-
function
|
|
1412
|
-
return e === void 0 ?
|
|
1411
|
+
function Tt(e, t) {
|
|
1412
|
+
return e === void 0 ? O(E.Never, {
|
|
1413
1413
|
type: "string",
|
|
1414
1414
|
maxLength: 0,
|
|
1415
1415
|
minLength: 1
|
|
1416
|
-
}, t) :
|
|
1416
|
+
}, t) : mt(e) ? D(e) === E.Never ? e : vt(e) : e;
|
|
1417
1417
|
}
|
|
1418
1418
|
//#endregion
|
|
1419
1419
|
//#region src/json-schema-subset/compiler/combination.ts
|
|
1420
|
-
var
|
|
1420
|
+
var Et = Object.freeze([
|
|
1421
1421
|
"allOf",
|
|
1422
1422
|
"anyOf",
|
|
1423
1423
|
"oneOf"
|
|
1424
1424
|
]);
|
|
1425
|
-
function
|
|
1426
|
-
if (n.length === 0) return
|
|
1425
|
+
function Dt(e, t, n, r) {
|
|
1426
|
+
if (n.length === 0) return rt(e, "disable empty list", t), null;
|
|
1427
1427
|
let i = [];
|
|
1428
1428
|
for (let [r, a] of n.entries()) {
|
|
1429
|
-
let n = A(
|
|
1429
|
+
let n = A(tt(e, t, r), nt(a));
|
|
1430
1430
|
n && i.push(n);
|
|
1431
1431
|
}
|
|
1432
1432
|
if (i.length < n.length) return null;
|
|
1433
1433
|
let a = 0, o = 0;
|
|
1434
|
-
for (let e of i) switch (
|
|
1435
|
-
case
|
|
1434
|
+
for (let e of i) switch (D(e)) {
|
|
1435
|
+
case E.Any:
|
|
1436
1436
|
a += 1;
|
|
1437
1437
|
break;
|
|
1438
|
-
case
|
|
1438
|
+
case E.Never: o += 1;
|
|
1439
1439
|
}
|
|
1440
|
-
let s =
|
|
1440
|
+
let s = E.Combination;
|
|
1441
1441
|
switch (t) {
|
|
1442
1442
|
case "allOf":
|
|
1443
|
-
o > 0 ? s =
|
|
1443
|
+
o > 0 ? s = E.Never : a === i.length ? s = E.Any : Ot(i) || (s = E.Never);
|
|
1444
1444
|
break;
|
|
1445
1445
|
case "anyOf":
|
|
1446
|
-
a > 0 ? s =
|
|
1446
|
+
a > 0 ? s = E.Any : o === i.length && (s = E.Never);
|
|
1447
1447
|
break;
|
|
1448
|
-
case "oneOf": a > 1 || o === i.length ? s =
|
|
1448
|
+
case "oneOf": a > 1 || o === i.length ? s = E.Never : a === 1 && o === i.length - 1 && (s = E.Any);
|
|
1449
1449
|
}
|
|
1450
|
-
return
|
|
1450
|
+
return O(s, { [t]: i }, r, e.path);
|
|
1451
1451
|
}
|
|
1452
|
-
function
|
|
1452
|
+
function Ot(e) {
|
|
1453
1453
|
let t = null;
|
|
1454
1454
|
for (let n of e) {
|
|
1455
|
-
let e =
|
|
1455
|
+
let e = D(n);
|
|
1456
1456
|
switch (e) {
|
|
1457
|
-
case
|
|
1458
|
-
case
|
|
1457
|
+
case E.Any:
|
|
1458
|
+
case E.Never: break;
|
|
1459
1459
|
default: if (t === null) t = e;
|
|
1460
1460
|
else if (t !== e) return !1;
|
|
1461
1461
|
}
|
|
@@ -1464,43 +1464,43 @@ function Dt(e) {
|
|
|
1464
1464
|
}
|
|
1465
1465
|
//#endregion
|
|
1466
1466
|
//#region src/json-schema-subset/checker/validator.ts
|
|
1467
|
-
var
|
|
1467
|
+
var k = Object.freeze({
|
|
1468
1468
|
Valid: 0,
|
|
1469
1469
|
Invalid: 1,
|
|
1470
1470
|
Unknown: 2
|
|
1471
1471
|
});
|
|
1472
1472
|
function kt(e, t) {
|
|
1473
1473
|
let n = e.isValid;
|
|
1474
|
-
return n ? n(t) === !0 ?
|
|
1474
|
+
return n ? n(t) === !0 ? k.Valid : k.Invalid : k.Unknown;
|
|
1475
1475
|
}
|
|
1476
1476
|
//#endregion
|
|
1477
1477
|
//#region src/json-schema-subset/compiler/enumAndConst.ts
|
|
1478
1478
|
function At(e, t, n, r) {
|
|
1479
1479
|
let i, a = !1;
|
|
1480
1480
|
if (t) {
|
|
1481
|
-
if (t.length === 0) return
|
|
1481
|
+
if (t.length === 0) return rt(e, "disable empty list", "enum"), null;
|
|
1482
1482
|
i = [];
|
|
1483
1483
|
for (let [n, a] of t.entries()) switch (kt(r, a)) {
|
|
1484
|
-
case
|
|
1485
|
-
i.push(
|
|
1484
|
+
case k.Valid:
|
|
1485
|
+
i.push(_t(a));
|
|
1486
1486
|
break;
|
|
1487
|
-
case
|
|
1487
|
+
case k.Invalid: T(e, "cannot pass JSON schema of currently schema object", "enum", n);
|
|
1488
1488
|
}
|
|
1489
|
-
i.length === 0 &&
|
|
1489
|
+
i.length === 0 && T(e, "all of elements from list is rejected by currently schema object", "enum");
|
|
1490
1490
|
}
|
|
1491
|
-
if (n && kt(r, n) ===
|
|
1491
|
+
if (n && kt(r, n) === k.Invalid && (a = !0), i) {
|
|
1492
1492
|
if (i.length === 0) a = !0;
|
|
1493
1493
|
else if (n) {
|
|
1494
1494
|
let e = !1;
|
|
1495
|
-
for (let t of i) if (
|
|
1495
|
+
for (let t of i) if (Oe(t, n)) {
|
|
1496
1496
|
e = !0;
|
|
1497
1497
|
break;
|
|
1498
1498
|
}
|
|
1499
1499
|
e || (a = !0);
|
|
1500
1500
|
}
|
|
1501
1501
|
}
|
|
1502
|
-
let o = a ?
|
|
1503
|
-
return r.type && (s.type = r.type), i && (s.enum = i), n && (s.const =
|
|
1502
|
+
let o = a ? E.Never : E.EnumOrConst, s = {};
|
|
1503
|
+
return r.type && (s.type = r.type), i && (s.enum = i), n && (s.const = _t(De(n))), O(o, s, e.delegate, e.path);
|
|
1504
1504
|
}
|
|
1505
1505
|
//#endregion
|
|
1506
1506
|
//#region src/json-schema-subset/compiler/object.ts
|
|
@@ -1516,14 +1516,14 @@ var jt = /* @__PURE__ */ new Set([
|
|
|
1516
1516
|
"propertyNames"
|
|
1517
1517
|
]);
|
|
1518
1518
|
function Mt(e, t) {
|
|
1519
|
-
let n = Object.keys(t).filter((e) => !jt.has(e) &&
|
|
1520
|
-
n.length > 0 &&
|
|
1519
|
+
let n = Object.keys(t).filter((e) => !jt.has(e) && $e(e));
|
|
1520
|
+
n.length > 0 && T(e, `type="object" will exclude other keys: ${n.toSorted().join(", ")}`);
|
|
1521
1521
|
let r = Nt(e, "maxProperties", t), i = Nt(e, "minProperties", t), a = Pt(e, t), o = Ft(e, t), s = It(e, t), c = Rt(e, t);
|
|
1522
1522
|
if (!a || !o || !s || !c) return null;
|
|
1523
1523
|
let l = Lt(e, o, s, t);
|
|
1524
1524
|
if (!l) return null;
|
|
1525
1525
|
let u = Bt(e, zt(a, o, s, l), c, t);
|
|
1526
|
-
return
|
|
1526
|
+
return O(Vt(e, a, l, u, r, i) ? E.Never : E.Object, at({
|
|
1527
1527
|
type: "object",
|
|
1528
1528
|
required: u,
|
|
1529
1529
|
properties: l,
|
|
@@ -1539,32 +1539,32 @@ function Nt(e, t, n) {
|
|
|
1539
1539
|
let r = n[t];
|
|
1540
1540
|
if (r !== void 0) {
|
|
1541
1541
|
if (Number.isNaN(r)) {
|
|
1542
|
-
|
|
1542
|
+
T(e, "find NaN", t);
|
|
1543
1543
|
return;
|
|
1544
1544
|
}
|
|
1545
1545
|
if (r < 0) {
|
|
1546
|
-
|
|
1546
|
+
T(e, `find invalid number ${r}`, t);
|
|
1547
1547
|
return;
|
|
1548
1548
|
}
|
|
1549
1549
|
return r;
|
|
1550
1550
|
}
|
|
1551
1551
|
}
|
|
1552
1552
|
function Pt(e, { additionalProperties: t }) {
|
|
1553
|
-
return t === !1 ?
|
|
1553
|
+
return t === !1 ? O(E.Never, {
|
|
1554
1554
|
type: "string",
|
|
1555
1555
|
maxLength: 0,
|
|
1556
1556
|
minLength: 1
|
|
1557
|
-
}, e.delegate, e.path) : typeof t == "object" ? A(
|
|
1557
|
+
}, e.delegate, e.path) : typeof t == "object" ? A(tt(e, "additionalProperties"), nt(t)) : O(E.Any, {}, e.delegate, e.path);
|
|
1558
1558
|
}
|
|
1559
1559
|
function Ft(e, { patternProperties: t }) {
|
|
1560
1560
|
let n = !1, r = {};
|
|
1561
1561
|
for (let i in t) {
|
|
1562
1562
|
let a = Gt(i);
|
|
1563
1563
|
if (a instanceof Error) {
|
|
1564
|
-
|
|
1564
|
+
T(e, `property name invalid. ${i}`, "patternProperties", i);
|
|
1565
1565
|
continue;
|
|
1566
1566
|
}
|
|
1567
|
-
let o =
|
|
1567
|
+
let o = nt(t[i]), s = A(tt(e, "patternProperties", i), o);
|
|
1568
1568
|
if (!s) {
|
|
1569
1569
|
n = !0;
|
|
1570
1570
|
continue;
|
|
@@ -1574,28 +1574,28 @@ function Ft(e, { patternProperties: t }) {
|
|
|
1574
1574
|
return n ? null : r;
|
|
1575
1575
|
}
|
|
1576
1576
|
function It(e, { propertyNames: t }) {
|
|
1577
|
-
if (!t) return
|
|
1578
|
-
t =
|
|
1579
|
-
let n = A(
|
|
1577
|
+
if (!t) return O(E.Any, {}, e.delegate, e.path);
|
|
1578
|
+
t = nt(t);
|
|
1579
|
+
let n = A(tt(e, "propertyNames"), t);
|
|
1580
1580
|
if (!n) return null;
|
|
1581
|
-
let r =
|
|
1582
|
-
return r !==
|
|
1581
|
+
let r = D(n);
|
|
1582
|
+
return r !== E.String && r !== E.Any ? vt(n) : n;
|
|
1583
1583
|
}
|
|
1584
1584
|
function Lt(e, t, n, { properties: r }) {
|
|
1585
1585
|
let i = !1;
|
|
1586
1586
|
if (!r) return {};
|
|
1587
1587
|
let a = {};
|
|
1588
1588
|
for (let o in r) {
|
|
1589
|
-
if (kt(n, o) ===
|
|
1590
|
-
|
|
1589
|
+
if (kt(n, o) === k.Invalid) {
|
|
1590
|
+
T(e, `key ${JSON.stringify(o)} cannot pass JSON schema from propertyNames`, "properties");
|
|
1591
1591
|
continue;
|
|
1592
1592
|
}
|
|
1593
1593
|
let s = Wt(t, o);
|
|
1594
|
-
if (s &&
|
|
1595
|
-
|
|
1594
|
+
if (s && D(s) === E.Never) {
|
|
1595
|
+
T(e, `key ${JSON.stringify(o)} matches a pattern that has a impossible(never) schema`, "properties");
|
|
1596
1596
|
continue;
|
|
1597
1597
|
}
|
|
1598
|
-
let c =
|
|
1598
|
+
let c = nt(r[o]), l = A(tt(e, "properties", o), c);
|
|
1599
1599
|
if (!l) {
|
|
1600
1600
|
i = !0;
|
|
1601
1601
|
continue;
|
|
@@ -1608,15 +1608,15 @@ function Rt(e, { dependencies: t }) {
|
|
|
1608
1608
|
if (!t) return [{}, {}];
|
|
1609
1609
|
let n = {}, r = {};
|
|
1610
1610
|
for (let i in t) {
|
|
1611
|
-
let a =
|
|
1611
|
+
let a = nt(t[i]);
|
|
1612
1612
|
if (Array.isArray(a)) {
|
|
1613
1613
|
let { keys: t, duplicated: r } = Ut(a);
|
|
1614
|
-
r &&
|
|
1614
|
+
r && T(e, `found duplicated property names: ${r.join(", ")}`, "dependencies", i), n[i] = t;
|
|
1615
1615
|
} else {
|
|
1616
|
-
let t = A(
|
|
1616
|
+
let t = A(tt(e, "dependencies", i), a);
|
|
1617
1617
|
if (t) {
|
|
1618
|
-
let e =
|
|
1619
|
-
r[i] = e ===
|
|
1618
|
+
let e = D(t);
|
|
1619
|
+
r[i] = e === E.Object || e === E.Any ? t : e === E.Extends ? ft : vt(t);
|
|
1620
1620
|
}
|
|
1621
1621
|
}
|
|
1622
1622
|
}
|
|
@@ -1624,27 +1624,27 @@ function Rt(e, { dependencies: t }) {
|
|
|
1624
1624
|
}
|
|
1625
1625
|
function zt(e, t, n, r) {
|
|
1626
1626
|
return (i) => {
|
|
1627
|
-
if (kt(n, i) ===
|
|
1627
|
+
if (kt(n, i) === k.Invalid) return !0;
|
|
1628
1628
|
let a = Wt(t, i);
|
|
1629
|
-
return !!(a &&
|
|
1629
|
+
return !!(a && D(a) === E.Never || D(r[i] ?? e) === E.Never);
|
|
1630
1630
|
};
|
|
1631
1631
|
}
|
|
1632
1632
|
function Bt(e, t, n, { required: r }) {
|
|
1633
1633
|
if (!r) return [];
|
|
1634
1634
|
let i = Ut(r);
|
|
1635
|
-
i.duplicated &&
|
|
1635
|
+
i.duplicated && T(e, `found duplicated required keys: ${i.duplicated.join(", ")}`, "required");
|
|
1636
1636
|
let a = [], o = [];
|
|
1637
1637
|
for (let e of i.keys) Ht(n, e).some((e) => t(e)) ? o.push(e) : a.push(e);
|
|
1638
|
-
return o.length > 0 &&
|
|
1638
|
+
return o.length > 0 && T(e, `key ${o.map((e) => JSON.stringify(e)).join(", ")} will ban by another condition`, "required"), a;
|
|
1639
1639
|
}
|
|
1640
1640
|
function Vt(e, t, n, r, i, a) {
|
|
1641
|
-
if (i !== void 0 && a !== void 0 && i < a) return
|
|
1642
|
-
if (i !== void 0 && r.length > i) return
|
|
1643
|
-
if (a !== void 0 && r.length < a) return
|
|
1644
|
-
if (
|
|
1641
|
+
if (i !== void 0 && a !== void 0 && i < a) return T(e, `maxProperties(${i}) is less than minProperties(${a})`), !0;
|
|
1642
|
+
if (i !== void 0 && r.length > i) return T(e, `length(${r.length}) of required is greater than maxProperties(${i})`), !0;
|
|
1643
|
+
if (a !== void 0 && r.length < a) return T(e, `length(${r.length}) of required is less than minProperties(${a})`), !0;
|
|
1644
|
+
if (D(t) !== E.Never) return !1;
|
|
1645
1645
|
for (let e in n) {
|
|
1646
1646
|
let t = n[e];
|
|
1647
|
-
if (
|
|
1647
|
+
if (D(t) !== E.Never) return !1;
|
|
1648
1648
|
}
|
|
1649
1649
|
return !0;
|
|
1650
1650
|
}
|
|
@@ -1652,7 +1652,7 @@ function Ht([e, t], n) {
|
|
|
1652
1652
|
let r = [n], i = new Set(r);
|
|
1653
1653
|
for (; r.length > 0;) {
|
|
1654
1654
|
let n = r.pop(), i = t[n], o = e[n];
|
|
1655
|
-
i &&
|
|
1655
|
+
i && D(i) === E.Object && a(i.required), o && a(o);
|
|
1656
1656
|
}
|
|
1657
1657
|
function a(e) {
|
|
1658
1658
|
if (e) for (let t of e) i.has(t) || (i.add(t), r.push(t));
|
|
@@ -1722,48 +1722,48 @@ function Xt(e, t) {
|
|
|
1722
1722
|
case "string": return $t(e, t);
|
|
1723
1723
|
case "boolean":
|
|
1724
1724
|
case "null": {
|
|
1725
|
-
let r = Object.keys(t).filter((e) =>
|
|
1726
|
-
return r.length > 0 &&
|
|
1725
|
+
let r = Object.keys(t).filter((e) => $e(e) && e !== "type");
|
|
1726
|
+
return r.length > 0 && T(e, `key "type" will exclude other keys: ${r.toSorted().join(", ")}`), O(n === "null" ? E.Null : E.Boolean, { type: n }, e.delegate, e.path);
|
|
1727
1727
|
}
|
|
1728
|
-
default: return
|
|
1728
|
+
default: return rt(e, `invalid type ${JSON.stringify(n)}`), null;
|
|
1729
1729
|
}
|
|
1730
1730
|
}
|
|
1731
1731
|
function Zt(e, t) {
|
|
1732
|
-
let n = Object.keys(t).filter((e) => !Jt.has(e) &&
|
|
1733
|
-
n.length > 0 &&
|
|
1734
|
-
let r =
|
|
1732
|
+
let n = Object.keys(t).filter((e) => !Jt.has(e) && $e(e));
|
|
1733
|
+
n.length > 0 && T(e, `type=${JSON.stringify(t.type)} will exclude other keys: ${n.toSorted().join(", ")}`);
|
|
1734
|
+
let r = Ee(t, Jt);
|
|
1735
1735
|
for (let t of Jt) {
|
|
1736
1736
|
let n = r[t];
|
|
1737
|
-
t !== "type" && n !== void 0 && Number.isNaN(n) && (
|
|
1737
|
+
t !== "type" && n !== void 0 && Number.isNaN(n) && (T(e, "found NaN", t), delete r[t]);
|
|
1738
1738
|
}
|
|
1739
1739
|
let { maximum: i, exclusiveMaximum: a, minimum: o, exclusiveMinimum: s } = r;
|
|
1740
1740
|
i !== void 0 && a !== void 0 && (i === a ? delete r.maximum : i < a ? delete r.exclusiveMaximum : i > a && delete r.maximum), o !== void 0 && s !== void 0 && (o === s ? delete r.minimum : o < s ? delete r.exclusiveMinimum : o > s && delete r.minimum);
|
|
1741
1741
|
let { multipleOf: c } = r;
|
|
1742
|
-
c === 0 && (delete r.multipleOf, r.type = "number",
|
|
1743
|
-
let l =
|
|
1744
|
-
return Qt(r) || (l =
|
|
1742
|
+
c === 0 && (delete r.multipleOf, r.type = "number", T(e, "cannot be 0", "multipleOf"));
|
|
1743
|
+
let l = E.Numeric;
|
|
1744
|
+
return Qt(r) || (l = E.Never), O(l, r, e.delegate, e.path);
|
|
1745
1745
|
}
|
|
1746
1746
|
function Qt(e) {
|
|
1747
1747
|
let { maximum: t, exclusiveMaximum: n, minimum: r, exclusiveMinimum: i } = e;
|
|
1748
1748
|
return t !== void 0 && r !== void 0 ? t >= r : n !== void 0 && r !== void 0 ? n > r : t !== void 0 && i !== void 0 ? t > i : n !== void 0 && i !== void 0 ? n > i : !0;
|
|
1749
1749
|
}
|
|
1750
1750
|
function $t(e, t) {
|
|
1751
|
-
let n = Object.keys(t).filter((e) => !Yt.has(e) &&
|
|
1752
|
-
n.length > 0 &&
|
|
1753
|
-
let r =
|
|
1751
|
+
let n = Object.keys(t).filter((e) => !Yt.has(e) && $e(e));
|
|
1752
|
+
n.length > 0 && T(e, `type="string" will exclude other keys: ${n.toSorted().join(", ")}`);
|
|
1753
|
+
let r = Ee(t, Yt);
|
|
1754
1754
|
en(e, r, "maxLength"), en(e, r, "minLength");
|
|
1755
|
-
let i = r.maxLength, a = r.minLength, o =
|
|
1756
|
-
return i !== void 0 && (i < 0 || i !== void 0 && a !== void 0 && i < a) && (o =
|
|
1755
|
+
let i = r.maxLength, a = r.minLength, o = E.String;
|
|
1756
|
+
return i !== void 0 && (i < 0 || i !== void 0 && a !== void 0 && i < a) && (o = E.Never), O(o, r, e.delegate, e.path);
|
|
1757
1757
|
}
|
|
1758
1758
|
function en(e, t, n) {
|
|
1759
1759
|
let r = t[n];
|
|
1760
|
-
r !== void 0 && Number.isNaN(r) && (
|
|
1760
|
+
r !== void 0 && Number.isNaN(r) && (T(e, "found NaN", n), delete t[n]);
|
|
1761
1761
|
}
|
|
1762
1762
|
//#endregion
|
|
1763
1763
|
//#region src/json-schema-subset/compiler/compiler.ts
|
|
1764
1764
|
var tn = Object.freeze([]);
|
|
1765
1765
|
function nn(e, t, n, r) {
|
|
1766
|
-
if (
|
|
1766
|
+
if (mt(e) || t.isExtendsSchema(e)) return {
|
|
1767
1767
|
schema: e,
|
|
1768
1768
|
warns: tn
|
|
1769
1769
|
};
|
|
@@ -1772,7 +1772,7 @@ function nn(e, t, n, r) {
|
|
|
1772
1772
|
if (typeof t == "object") {
|
|
1773
1773
|
let e = [];
|
|
1774
1774
|
for (let n of t) e.push({
|
|
1775
|
-
kind:
|
|
1775
|
+
kind: Ye.External,
|
|
1776
1776
|
error: n
|
|
1777
1777
|
});
|
|
1778
1778
|
if (e.length > 0) return e;
|
|
@@ -1797,7 +1797,7 @@ function rn(e, t) {
|
|
|
1797
1797
|
if (!e) throw Error(t);
|
|
1798
1798
|
}
|
|
1799
1799
|
function A(e, t) {
|
|
1800
|
-
if (e.extends.isExtendsSchema(t) ||
|
|
1800
|
+
if (e.extends.isExtendsSchema(t) || mt(t)) return t;
|
|
1801
1801
|
let n = e.extends.tryCompiledExtendsSchema(t, e.payload);
|
|
1802
1802
|
if (n) return n;
|
|
1803
1803
|
let r = t, i = !1, { enum: a, const: o } = t;
|
|
@@ -1809,46 +1809,46 @@ function A(e, t) {
|
|
|
1809
1809
|
return s && i && (s = At(e, a, o, s)), s || null;
|
|
1810
1810
|
}
|
|
1811
1811
|
function an(e, t) {
|
|
1812
|
-
for (let n of
|
|
1812
|
+
for (let n of Et) {
|
|
1813
1813
|
let r = t[n];
|
|
1814
1814
|
if (r) {
|
|
1815
|
-
let i = Object.keys(t).filter((e) =>
|
|
1816
|
-
return i.length > 0 &&
|
|
1815
|
+
let i = Object.keys(t).filter((e) => $e(e) && e !== n);
|
|
1816
|
+
return i.length > 0 && T(e, `composition key ${JSON.stringify(n)} will exclude other keys: ${i.toSorted().join(", ")}`), Dt(e, n, r) || null;
|
|
1817
1817
|
}
|
|
1818
1818
|
}
|
|
1819
1819
|
{
|
|
1820
|
-
let n =
|
|
1820
|
+
let n = nt(t.not);
|
|
1821
1821
|
if (n) {
|
|
1822
|
-
let r = Object.keys(t).filter((e) =>
|
|
1823
|
-
r.length > 0 &&
|
|
1824
|
-
let i = A(
|
|
1822
|
+
let r = Object.keys(t).filter((e) => $e(e) && e !== "not");
|
|
1823
|
+
r.length > 0 && T(e, `key "not" will exclude other keys: ${r.toSorted().join(", ")}`);
|
|
1824
|
+
let i = A(tt(e, "not"), n);
|
|
1825
1825
|
if (!i) return null;
|
|
1826
|
-
let a =
|
|
1827
|
-
switch (
|
|
1828
|
-
case
|
|
1829
|
-
a =
|
|
1826
|
+
let a = E.Not;
|
|
1827
|
+
switch (D(i)) {
|
|
1828
|
+
case E.Never:
|
|
1829
|
+
a = E.Any;
|
|
1830
1830
|
break;
|
|
1831
|
-
case
|
|
1831
|
+
case E.Any: a = E.Never;
|
|
1832
1832
|
}
|
|
1833
|
-
return
|
|
1833
|
+
return O(a, { not: i }, e.delegate, e.path);
|
|
1834
1834
|
}
|
|
1835
1835
|
}
|
|
1836
1836
|
if (t.type) {
|
|
1837
1837
|
let { type: n } = t;
|
|
1838
1838
|
if (Array.isArray(n)) {
|
|
1839
1839
|
let { type: r, ...i } = t;
|
|
1840
|
-
return
|
|
1840
|
+
return Dt(e, "anyOf", n.map((e) => ({
|
|
1841
1841
|
...i,
|
|
1842
1842
|
type: e
|
|
1843
1843
|
})));
|
|
1844
1844
|
}
|
|
1845
1845
|
switch (n) {
|
|
1846
1846
|
case "object": return Mt(e, t);
|
|
1847
|
-
case "array": return
|
|
1847
|
+
case "array": return bt(e, t);
|
|
1848
1848
|
default: return Xt(e, t);
|
|
1849
1849
|
}
|
|
1850
1850
|
}
|
|
1851
|
-
return
|
|
1851
|
+
return et(t) ? O(E.Any, {}, e.delegate, e.path) : (rt(e, "unrecognized"), null);
|
|
1852
1852
|
}
|
|
1853
1853
|
//#endregion
|
|
1854
1854
|
//#region src/json-schema-subset/checker/tools/mark.ts
|
|
@@ -1930,7 +1930,7 @@ var ln = class {
|
|
|
1930
1930
|
}
|
|
1931
1931
|
push(e, t) {
|
|
1932
1932
|
let n = /* @__PURE__ */ new Set();
|
|
1933
|
-
for (let r of this.values) for (let [i, a] of
|
|
1933
|
+
for (let r of this.values) for (let [i, a] of ke) if (e & a) {
|
|
1934
1934
|
let e = this.description.toBundle(r);
|
|
1935
1935
|
t(i, e), n.add(e.toInt32());
|
|
1936
1936
|
}
|
|
@@ -2122,9 +2122,9 @@ var hn = (e) => (t = e, n = Infinity, r = e, i = Infinity) => {
|
|
|
2122
2122
|
};
|
|
2123
2123
|
};
|
|
2124
2124
|
function gn({ left: e, right: t, intersection: n }) {
|
|
2125
|
-
if (!n) return
|
|
2125
|
+
if (!n) return g.Rejection;
|
|
2126
2126
|
let r = !1, i = !1;
|
|
2127
|
-
return e && (e.isFrom1 ? r = !0 : i = !0), t && (t.isFrom1 ? r = !0 : i = !0), r && i ?
|
|
2127
|
+
return e && (e.isFrom1 ? r = !0 : i = !0), t && (t.isFrom1 ? r = !0 : i = !0), r && i ? g.Intersection : r ? g.Containing : i ? g.ContainedBy : g.Equals;
|
|
2128
2128
|
}
|
|
2129
2129
|
//#endregion
|
|
2130
2130
|
//#region src/json-schema-subset/checker/array.ts
|
|
@@ -2137,57 +2137,57 @@ var _n = hn(0), vn = cn([
|
|
|
2137
2137
|
]);
|
|
2138
2138
|
function yn({ calculate: e }, t, n) {
|
|
2139
2139
|
let r = _n(t.minItems, t.maxItems, n.minItems, n.maxItems), i = gn(r);
|
|
2140
|
-
if (i ===
|
|
2140
|
+
if (i === g.Rejection) return b;
|
|
2141
2141
|
let [a, o] = bn(t), [s, c] = bn(n), l = Math.max(a.length, s.length) + 1, u = Math.min(l, r.intersection.max), d = vn.variable({}), f = Math.min(t.minItems ?? 0, n.minItems ?? 0);
|
|
2142
2142
|
for (let t = 0; t < u; t++) {
|
|
2143
2143
|
let n = e(a[t] ?? o, s[t] ?? c);
|
|
2144
2144
|
d.push(n, (e, n) => {
|
|
2145
2145
|
switch (e) {
|
|
2146
|
-
case
|
|
2146
|
+
case g.Equals:
|
|
2147
2147
|
n.hasRejection || (n.hasCommon = !0);
|
|
2148
2148
|
break;
|
|
2149
|
-
case
|
|
2149
|
+
case g.Containing:
|
|
2150
2150
|
n.hasRejection || (n.hasCommon = !0), n.hasExtra1 = !0;
|
|
2151
2151
|
break;
|
|
2152
|
-
case
|
|
2152
|
+
case g.ContainedBy:
|
|
2153
2153
|
n.hasRejection || (n.hasCommon = !0), n.hasExtra2 = !0;
|
|
2154
2154
|
break;
|
|
2155
|
-
case
|
|
2155
|
+
case g.Intersection:
|
|
2156
2156
|
n.hasRejection || (n.hasCommon = !0), n.hasExtra1 = !0, n.hasExtra2 = !0;
|
|
2157
2157
|
break;
|
|
2158
|
-
case
|
|
2158
|
+
case g.Rejection: t < f && (n.hasCommonBroken = !0), n.hasRejection = !0, n.hasExtra1 = !0, n.hasExtra2 = !0;
|
|
2159
2159
|
}
|
|
2160
2160
|
});
|
|
2161
2161
|
}
|
|
2162
2162
|
d.update((e) => {
|
|
2163
2163
|
switch (i) {
|
|
2164
|
-
case
|
|
2164
|
+
case g.Containing:
|
|
2165
2165
|
e.hasExtra1 = !0;
|
|
2166
2166
|
break;
|
|
2167
|
-
case
|
|
2167
|
+
case g.ContainedBy:
|
|
2168
2168
|
e.hasExtra2 = !0;
|
|
2169
2169
|
break;
|
|
2170
|
-
case
|
|
2170
|
+
case g.Intersection: e.hasExtra1 = !0, e.hasExtra2 = !0;
|
|
2171
2171
|
}
|
|
2172
2172
|
t.uniqueItems && !n.uniqueItems && (n.maxItems ?? Infinity) > 1 ? e.hasExtra2 = !0 : !t.uniqueItems && n.uniqueItems && (t.maxItems ?? Infinity) > 1 && (e.hasExtra1 = !0), (t.maxItems === 0 || n.maxItems === 0) && (e.hasCommon = !0, t.maxItems !== 0 && (e.hasExtra1 = !0), n.maxItems !== 0 && (e.hasExtra2 = !0));
|
|
2173
2173
|
});
|
|
2174
2174
|
let p = 0;
|
|
2175
2175
|
for (let { hasExtra1: e, hasExtra2: t, hasCommon: n, hasCommonBroken: r } of d) {
|
|
2176
2176
|
let i = n;
|
|
2177
|
-
r && (i = !1), p |= i ? e && t ?
|
|
2177
|
+
r && (i = !1), p |= i ? e && t ? x : e ? v : t ? y : _ : b;
|
|
2178
2178
|
}
|
|
2179
2179
|
return p;
|
|
2180
2180
|
}
|
|
2181
2181
|
function bn({ items: e, additionalItems: t }) {
|
|
2182
|
-
return Array.isArray(e) ? [e, t ??
|
|
2182
|
+
return Array.isArray(e) ? [e, t ?? dt] : [[], e ?? dt];
|
|
2183
2183
|
}
|
|
2184
2184
|
//#endregion
|
|
2185
2185
|
//#region src/json-schema-subset/checker/cache.ts
|
|
2186
2186
|
function xn(e) {
|
|
2187
2187
|
let t = /* @__PURE__ */ new Map();
|
|
2188
2188
|
return (n, r) => {
|
|
2189
|
-
let i =
|
|
2190
|
-
return i ===
|
|
2189
|
+
let i = pt(n);
|
|
2190
|
+
return i === pt(r) ? i ? Cn(t, n, r, e) : n === r : !1;
|
|
2191
2191
|
};
|
|
2192
2192
|
}
|
|
2193
2193
|
function Sn(e) {
|
|
@@ -2195,7 +2195,7 @@ function Sn(e) {
|
|
|
2195
2195
|
return (n, r) => Cn(t, n, r, e);
|
|
2196
2196
|
}
|
|
2197
2197
|
function Cn(e, t, n, r) {
|
|
2198
|
-
let i = `${
|
|
2198
|
+
let i = `${ht(t)}/${ht(n)}`, a = e.get(i);
|
|
2199
2199
|
return a === void 0 && e.set(i, a = r(t, n)), a;
|
|
2200
2200
|
}
|
|
2201
2201
|
//#endregion
|
|
@@ -2204,23 +2204,23 @@ function wn(e, t, n) {
|
|
|
2204
2204
|
let r = En(t), i = En(n), a = !1, o = !1, s = !1;
|
|
2205
2205
|
for (let t of r) if (Dn(e, i, t) ? s = !0 : a = !0, a && s) break;
|
|
2206
2206
|
for (let t of i) if (Dn(e, r, t) ? s = !0 : o = !0, o && s) break;
|
|
2207
|
-
return s ? a && o ?
|
|
2207
|
+
return s ? a && o ? x : a ? v : o ? y : _ : b;
|
|
2208
2208
|
}
|
|
2209
2209
|
function Tn(e, t) {
|
|
2210
2210
|
let n = !1, r = !1;
|
|
2211
2211
|
for (let i of En(e)) {
|
|
2212
2212
|
switch (kt(t, i)) {
|
|
2213
|
-
case
|
|
2213
|
+
case k.Valid:
|
|
2214
2214
|
n = !0;
|
|
2215
2215
|
break;
|
|
2216
|
-
case
|
|
2216
|
+
case k.Invalid:
|
|
2217
2217
|
r = !0;
|
|
2218
2218
|
break;
|
|
2219
|
-
case
|
|
2219
|
+
case k.Unknown: return S;
|
|
2220
2220
|
}
|
|
2221
2221
|
if (n && r) break;
|
|
2222
2222
|
}
|
|
2223
|
-
return n && r ?
|
|
2223
|
+
return n && r ? x : n ? _ | y : r ? b : D(t) === E.Never ? _ : y;
|
|
2224
2224
|
}
|
|
2225
2225
|
function En({ const: e, enum: t }) {
|
|
2226
2226
|
if (e !== void 0) return [e];
|
|
@@ -2240,7 +2240,7 @@ function On(e) {
|
|
|
2240
2240
|
}
|
|
2241
2241
|
let n = /* @__PURE__ */ new Map();
|
|
2242
2242
|
function r(e, t) {
|
|
2243
|
-
let r =
|
|
2243
|
+
let r = ht(e), a = ht(t);
|
|
2244
2244
|
if (r === a) return !0;
|
|
2245
2245
|
let o = `${r}/${a}`, s = n.get(o);
|
|
2246
2246
|
return s === void 0 && (s = i(e, t), n.set(o, s)), s;
|
|
@@ -2257,7 +2257,7 @@ function On(e) {
|
|
|
2257
2257
|
return !0;
|
|
2258
2258
|
}
|
|
2259
2259
|
function a(e, t) {
|
|
2260
|
-
return e === t ? !0 : typeof e != "object" || !e || typeof e != typeof t ? !1 :
|
|
2260
|
+
return e === t ? !0 : typeof e != "object" || !e || typeof e != typeof t ? !1 : mt(e) && mt(t) ? r(e, t) : i(e, t);
|
|
2261
2261
|
}
|
|
2262
2262
|
return t;
|
|
2263
2263
|
}
|
|
@@ -2294,17 +2294,17 @@ function Nn(e, t) {
|
|
|
2294
2294
|
//#region src/json-schema-subset/checker/numeric/float.ts
|
|
2295
2295
|
function Pn(e, t) {
|
|
2296
2296
|
let { left: n, right: r, center: i } = dn(In(e), In(t));
|
|
2297
|
-
if (!i) return
|
|
2297
|
+
if (!i) return b;
|
|
2298
2298
|
let a = !1, o = !1;
|
|
2299
|
-
return n && (n.fromLeft ? a = !0 : o = !0), r && (r.fromLeft ? a = !0 : o = !0), a && o ?
|
|
2299
|
+
return n && (n.fromLeft ? a = !0 : o = !0), r && (r.fromLeft ? a = !0 : o = !0), a && o ? x : a ? v : o ? y : _;
|
|
2300
2300
|
}
|
|
2301
2301
|
function Fn(e, t) {
|
|
2302
2302
|
let n = In(e), r = kn(t);
|
|
2303
|
-
if (!r) return
|
|
2303
|
+
if (!r) return v;
|
|
2304
2304
|
let i = dn(n, r.range), a = jn(i.center, r.multipleOf), o = Ln(i.left, r.multipleOf), s = Ln(i.right, r.multipleOf);
|
|
2305
|
-
if (!i.center) return
|
|
2305
|
+
if (!i.center) return b;
|
|
2306
2306
|
let c = !1, l = !1;
|
|
2307
|
-
return i.left?.fromLeft && (c = !0), i.right?.fromLeft && (c = !0), (!a || !An(i.center)) && (c = !0), o && (l = !0), s && (l = !0), c && l ?
|
|
2307
|
+
return i.left?.fromLeft && (c = !0), i.right?.fromLeft && (c = !0), (!a || !An(i.center)) && (c = !0), o && (l = !0), s && (l = !0), c && l ? x : c ? v : l ? y : _;
|
|
2308
2308
|
}
|
|
2309
2309
|
function In(e) {
|
|
2310
2310
|
let t, n;
|
|
@@ -2335,13 +2335,13 @@ function Ln(e, t) {
|
|
|
2335
2335
|
//#region src/json-schema-subset/checker/numeric/integer.ts
|
|
2336
2336
|
function Rn(e, t) {
|
|
2337
2337
|
let n = kn(e), r = kn(t);
|
|
2338
|
-
if (!n && !r) return
|
|
2339
|
-
if (!n) return
|
|
2340
|
-
if (!r) return
|
|
2338
|
+
if (!n && !r) return _;
|
|
2339
|
+
if (!n) return y;
|
|
2340
|
+
if (!r) return v;
|
|
2341
2341
|
let { range: i, multipleOf: a } = n, { range: o, multipleOf: s } = r, c = dn(i, o), l, u = 0;
|
|
2342
|
-
if (c.center && (u = Bn(a, s), l = jn(c.center, u)), !l) return
|
|
2342
|
+
if (c.center && (u = Bn(a, s), l = jn(c.center, u)), !l) return b;
|
|
2343
2343
|
let d = !1, f = !1, { left: p, right: m } = c;
|
|
2344
|
-
return p && jn(p.range, p.fromLeft ? a : s) && (p.fromLeft ? d = !0 : f = !0), m && jn(m.range, m.fromLeft ? a : s) && (m.fromLeft ? d = !0 : f = !0), d ||= zn(n, l, u), f ||= zn(r, l, u), d && f ?
|
|
2344
|
+
return p && jn(p.range, p.fromLeft ? a : s) && (p.fromLeft ? d = !0 : f = !0), m && jn(m.range, m.fromLeft ? a : s) && (m.fromLeft ? d = !0 : f = !0), d ||= zn(n, l, u), f ||= zn(r, l, u), d && f ? x : d ? v : f ? y : _;
|
|
2345
2345
|
}
|
|
2346
2346
|
function zn({ range: e, multipleOf: t }, n, r) {
|
|
2347
2347
|
let i = dn(e, n);
|
|
@@ -2365,9 +2365,9 @@ function Hn(e) {
|
|
|
2365
2365
|
//#endregion
|
|
2366
2366
|
//#region src/json-schema-subset/checker/numeric/checker.ts
|
|
2367
2367
|
function Un(e, t) {
|
|
2368
|
-
if (Wn(e) || Wn(t)) return
|
|
2368
|
+
if (Wn(e) || Wn(t)) return S;
|
|
2369
2369
|
let n = Gn(e), r = Gn(t);
|
|
2370
|
-
return n && r ? Pn(e, t) : n ? Fn(e, t) : r ?
|
|
2370
|
+
return n && r ? Pn(e, t) : n ? Fn(e, t) : r ? Re(Fn(t, e)) : Rn(e, t);
|
|
2371
2371
|
}
|
|
2372
2372
|
function Wn(e) {
|
|
2373
2373
|
let { multipleOf: t } = e;
|
|
@@ -2387,9 +2387,9 @@ var Kn = hn(0), qn = cn([
|
|
|
2387
2387
|
"hasRejection"
|
|
2388
2388
|
]);
|
|
2389
2389
|
function Jn(e, t, n) {
|
|
2390
|
-
if (Yn(t, n)) return
|
|
2390
|
+
if (Yn(t, n)) return b;
|
|
2391
2391
|
let r = Xn(t, n);
|
|
2392
|
-
if (!r) return
|
|
2392
|
+
if (!r) return b;
|
|
2393
2393
|
let i = nr(t), a = nr(n), o = (t) => {
|
|
2394
2394
|
let n = i(t), r = a(t);
|
|
2395
2395
|
return rr(n, r) ? e.calculate(n, r) : 0;
|
|
@@ -2404,7 +2404,7 @@ function Jn(e, t, n) {
|
|
|
2404
2404
|
let t = o(e);
|
|
2405
2405
|
t !== 0 && u.push(t, r);
|
|
2406
2406
|
}
|
|
2407
|
-
let i = t.additionalProperties ??
|
|
2407
|
+
let i = t.additionalProperties ?? dt, a = n.additionalProperties ?? dt;
|
|
2408
2408
|
if (rr(i, a)) {
|
|
2409
2409
|
let t = e.calculate(i, a);
|
|
2410
2410
|
u.push(t, r);
|
|
@@ -2414,11 +2414,11 @@ function Jn(e, t, n) {
|
|
|
2414
2414
|
e.hasRejection || (c.size > 0 && (e.hasExtra2 = !0), l.size > 0 && (e.hasExtra1 = !0));
|
|
2415
2415
|
});
|
|
2416
2416
|
let { requiredKeysCount: p } = r, m = 0;
|
|
2417
|
-
for (let { hasExtra1: e, hasExtra2: t, hasCommonInRequired: n, hasCommonOutRequired: r, hasRejection: i } of u) m |= !n && p > 0 || !r && p === 0 || i ?
|
|
2417
|
+
for (let { hasExtra1: e, hasExtra2: t, hasCommonInRequired: n, hasCommonOutRequired: r, hasRejection: i } of u) m |= !n && p > 0 || !r && p === 0 || i ? b : e && t ? x : e ? v : t ? y : _;
|
|
2418
2418
|
return m;
|
|
2419
2419
|
}
|
|
2420
2420
|
function Yn(e, t) {
|
|
2421
|
-
return gn(Kn(e.minProperties, e.maxProperties, t.minProperties, t.maxProperties)) ===
|
|
2421
|
+
return gn(Kn(e.minProperties, e.maxProperties, t.minProperties, t.maxProperties)) === g.Rejection;
|
|
2422
2422
|
}
|
|
2423
2423
|
function Xn(e, t) {
|
|
2424
2424
|
let n = new Set(e.required), r = new Set(t.required), i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = n.size, s = r.size;
|
|
@@ -2446,61 +2446,61 @@ function Zn(e, t) {
|
|
|
2446
2446
|
}
|
|
2447
2447
|
var Qn = (e, t) => {
|
|
2448
2448
|
switch (e) {
|
|
2449
|
-
case
|
|
2449
|
+
case g.Equals:
|
|
2450
2450
|
t.hasCommonInRequired = !0;
|
|
2451
2451
|
break;
|
|
2452
|
-
case
|
|
2452
|
+
case g.Containing:
|
|
2453
2453
|
t.hasExtra1 = !0, t.hasCommonInRequired = !0;
|
|
2454
2454
|
break;
|
|
2455
|
-
case
|
|
2455
|
+
case g.ContainedBy:
|
|
2456
2456
|
t.hasExtra2 = !0, t.hasCommonInRequired = !0;
|
|
2457
2457
|
break;
|
|
2458
|
-
case
|
|
2458
|
+
case g.Intersection:
|
|
2459
2459
|
t.hasExtra1 = !0, t.hasExtra2 = !0, t.hasCommonInRequired = !0;
|
|
2460
2460
|
break;
|
|
2461
|
-
case
|
|
2461
|
+
case g.Rejection: t.hasRejection = !0;
|
|
2462
2462
|
}
|
|
2463
2463
|
}, $n = (e, t) => {
|
|
2464
2464
|
switch (e) {
|
|
2465
|
-
case
|
|
2466
|
-
case
|
|
2465
|
+
case g.Equals:
|
|
2466
|
+
case g.ContainedBy:
|
|
2467
2467
|
t.hasCommonInRequired = !0;
|
|
2468
2468
|
break;
|
|
2469
|
-
case
|
|
2470
|
-
case
|
|
2469
|
+
case g.Intersection:
|
|
2470
|
+
case g.Containing:
|
|
2471
2471
|
t.hasExtra1 = !0, t.hasCommonInRequired = !0;
|
|
2472
2472
|
break;
|
|
2473
|
-
case
|
|
2473
|
+
case g.Rejection: t.hasRejection = !0;
|
|
2474
2474
|
}
|
|
2475
2475
|
}, er = (e, t) => {
|
|
2476
2476
|
switch (e) {
|
|
2477
|
-
case
|
|
2478
|
-
case
|
|
2477
|
+
case g.Equals:
|
|
2478
|
+
case g.Containing:
|
|
2479
2479
|
t.hasCommonInRequired = !0;
|
|
2480
2480
|
break;
|
|
2481
|
-
case
|
|
2482
|
-
case
|
|
2481
|
+
case g.Intersection:
|
|
2482
|
+
case g.ContainedBy:
|
|
2483
2483
|
t.hasExtra2 = !0, t.hasCommonInRequired = !0;
|
|
2484
2484
|
break;
|
|
2485
|
-
case
|
|
2485
|
+
case g.Rejection: t.hasRejection = !0;
|
|
2486
2486
|
}
|
|
2487
2487
|
}, tr = (e, t) => (n, r) => {
|
|
2488
2488
|
if (r.hasRejection) return;
|
|
2489
2489
|
let i = !1, a = !1, o = !1;
|
|
2490
2490
|
switch (n) {
|
|
2491
|
-
case
|
|
2491
|
+
case g.Equals:
|
|
2492
2492
|
o = !0;
|
|
2493
2493
|
break;
|
|
2494
|
-
case
|
|
2494
|
+
case g.Containing:
|
|
2495
2495
|
i = !0, o = !0;
|
|
2496
2496
|
break;
|
|
2497
|
-
case
|
|
2497
|
+
case g.ContainedBy:
|
|
2498
2498
|
a = !0, o = !0;
|
|
2499
2499
|
break;
|
|
2500
|
-
case
|
|
2500
|
+
case g.Intersection:
|
|
2501
2501
|
i = !0, a = !0, o = !0;
|
|
2502
2502
|
break;
|
|
2503
|
-
case
|
|
2503
|
+
case g.Rejection: i = !0, a = !0;
|
|
2504
2504
|
}
|
|
2505
2505
|
e && i && (r.hasExtra1 = !0), t && a && (r.hasExtra2 = !0), e && t && o && (r.hasCommonOutRequired = !0);
|
|
2506
2506
|
};
|
|
@@ -2514,40 +2514,40 @@ function nr(e) {
|
|
|
2514
2514
|
});
|
|
2515
2515
|
}
|
|
2516
2516
|
return (e) => {
|
|
2517
|
-
if (n && kt(n, e) ===
|
|
2517
|
+
if (n && kt(n, e) === k.Invalid) return ft;
|
|
2518
2518
|
for (let { pattern: t, schema: n } of i) if (t.test(e)) return n;
|
|
2519
|
-
return ((t && t[e]) ?? r) ||
|
|
2519
|
+
return ((t && t[e]) ?? r) || dt;
|
|
2520
2520
|
};
|
|
2521
2521
|
}
|
|
2522
2522
|
function rr(e, t) {
|
|
2523
|
-
let n =
|
|
2524
|
-
return n !==
|
|
2523
|
+
let n = D(e), r = D(t);
|
|
2524
|
+
return n !== E.Never || r !== E.Never;
|
|
2525
2525
|
}
|
|
2526
2526
|
//#endregion
|
|
2527
2527
|
//#region src/json-schema-subset/checker/string.ts
|
|
2528
2528
|
var ir = hn(0);
|
|
2529
2529
|
function ar(e, t) {
|
|
2530
|
-
if (t.format && !e.format) return
|
|
2531
|
-
if (e.format && t.format && e.format !== t.format) return
|
|
2530
|
+
if (t.format && !e.format) return v;
|
|
2531
|
+
if (e.format && t.format && e.format !== t.format) return S;
|
|
2532
2532
|
let n = gn(ir(e.minLength, e.maxLength, t.minLength, t.maxLength)), r = !!e.pattern, i = !!t.pattern;
|
|
2533
2533
|
switch (n) {
|
|
2534
|
-
case
|
|
2535
|
-
case
|
|
2536
|
-
case
|
|
2537
|
-
case
|
|
2538
|
-
case
|
|
2534
|
+
case g.Rejection: return b;
|
|
2535
|
+
case g.Containing: return r ? S : v;
|
|
2536
|
+
case g.ContainedBy: return i ? S : y;
|
|
2537
|
+
case g.Equals: return r && i ? e.pattern === t.pattern ? _ : S : r ? _ | y : i ? _ | v : _;
|
|
2538
|
+
case g.Intersection: return r && i ? S : r ? x | b | y : i ? x | b | v : x;
|
|
2539
2539
|
}
|
|
2540
2540
|
}
|
|
2541
2541
|
//#endregion
|
|
2542
2542
|
//#region src/json-schema-subset/checker/checker.ts
|
|
2543
2543
|
function or(e, t, n) {
|
|
2544
2544
|
let r = {}, i = [], a = Sn(cr(e, r)), o = sr(), s = On(e);
|
|
2545
|
-
r.isEquals = xn(
|
|
2545
|
+
r.isEquals = xn(Oe), r.calculate = qe({
|
|
2546
2546
|
describe: o,
|
|
2547
2547
|
equals: s,
|
|
2548
2548
|
calculate: a,
|
|
2549
2549
|
observeCalculation: (e, t, n, r) => {
|
|
2550
|
-
if (!ur(r ?
|
|
2550
|
+
if (!ur(r ? Re(n) : n)) return;
|
|
2551
2551
|
let a = r ? dr(t, e) : dr(e, t);
|
|
2552
2552
|
a && i.push(a);
|
|
2553
2553
|
}
|
|
@@ -2560,93 +2560,93 @@ function or(e, t, n) {
|
|
|
2560
2560
|
}
|
|
2561
2561
|
var sr = () => (e) => {
|
|
2562
2562
|
let t;
|
|
2563
|
-
switch (
|
|
2564
|
-
case
|
|
2563
|
+
switch (D(e)) {
|
|
2564
|
+
case E.Not:
|
|
2565
2565
|
t = {
|
|
2566
|
-
kind:
|
|
2566
|
+
kind: Ke.Not,
|
|
2567
2567
|
expression: e.not
|
|
2568
2568
|
};
|
|
2569
2569
|
break;
|
|
2570
|
-
case
|
|
2570
|
+
case E.Combination:
|
|
2571
2571
|
if ("allOf" in e) t = {
|
|
2572
|
-
kind:
|
|
2573
|
-
expressions: lr(e.allOf,
|
|
2572
|
+
kind: Ke.AllOf,
|
|
2573
|
+
expressions: lr(e.allOf, E.Any)
|
|
2574
2574
|
};
|
|
2575
2575
|
else if ("anyOf" in e) t = {
|
|
2576
|
-
kind:
|
|
2577
|
-
expressions: lr(e.anyOf,
|
|
2576
|
+
kind: Ke.AnyOf,
|
|
2577
|
+
expressions: lr(e.anyOf, E.Never)
|
|
2578
2578
|
};
|
|
2579
2579
|
else if ("oneOf" in e) t = {
|
|
2580
|
-
kind:
|
|
2581
|
-
expressions: lr(e.oneOf,
|
|
2580
|
+
kind: Ke.OneOf,
|
|
2581
|
+
expressions: lr(e.oneOf, E.Never)
|
|
2582
2582
|
};
|
|
2583
2583
|
else throw Error(`invalid combination JSON Schema: ${JSON.stringify(e)}`);
|
|
2584
2584
|
break;
|
|
2585
|
-
default: t = { kind:
|
|
2585
|
+
default: t = { kind: Ke.Leaf };
|
|
2586
2586
|
}
|
|
2587
2587
|
return t;
|
|
2588
2588
|
}, cr = (e, t) => (n, r) => {
|
|
2589
|
-
let i =
|
|
2590
|
-
if (i ===
|
|
2589
|
+
let i = D(n), a = D(r);
|
|
2590
|
+
if (i === E.Extends || a === E.Extends) return e.calculate(n, r);
|
|
2591
2591
|
switch (i) {
|
|
2592
|
-
case
|
|
2593
|
-
case
|
|
2592
|
+
case E.Any: return a === E.Any ? _ : v;
|
|
2593
|
+
case E.Never: return a === E.Never ? _ : y;
|
|
2594
2594
|
}
|
|
2595
2595
|
switch (a) {
|
|
2596
|
-
case
|
|
2597
|
-
case
|
|
2596
|
+
case E.Any: return y;
|
|
2597
|
+
case E.Never: return v;
|
|
2598
2598
|
}
|
|
2599
|
-
if (i ===
|
|
2600
|
-
if (i ===
|
|
2601
|
-
if (a ===
|
|
2602
|
-
if (i !== a) return
|
|
2599
|
+
if (i === E.EnumOrConst && a === E.EnumOrConst) return wn(t, n, r);
|
|
2600
|
+
if (i === E.EnumOrConst) return Tn(n, r);
|
|
2601
|
+
if (a === E.EnumOrConst) return Re(Tn(r, n));
|
|
2602
|
+
if (i !== a) return b;
|
|
2603
2603
|
switch (i) {
|
|
2604
|
-
case
|
|
2605
|
-
case
|
|
2606
|
-
case
|
|
2607
|
-
case
|
|
2608
|
-
case
|
|
2609
|
-
case
|
|
2604
|
+
case E.Null: return _;
|
|
2605
|
+
case E.Numeric: return Un(n, r);
|
|
2606
|
+
case E.String: return ar(n, r);
|
|
2607
|
+
case E.Boolean: return _;
|
|
2608
|
+
case E.Object: return Jn(t, n, r);
|
|
2609
|
+
case E.Array: return yn(t, n, r);
|
|
2610
2610
|
default: throw Error(`invalid kind ${i}`);
|
|
2611
2611
|
}
|
|
2612
2612
|
};
|
|
2613
2613
|
function lr(e, t) {
|
|
2614
|
-
return e.filter((e) =>
|
|
2614
|
+
return e.filter((e) => D(e) !== t);
|
|
2615
2615
|
}
|
|
2616
2616
|
function ur(e) {
|
|
2617
|
-
return !
|
|
2617
|
+
return !Ae(e) && !Me(e) && (je(e) || Pe(e) || Ne(e));
|
|
2618
2618
|
}
|
|
2619
2619
|
function dr(e, t) {
|
|
2620
|
-
let n =
|
|
2620
|
+
let n = gt(t);
|
|
2621
2621
|
if (!n) return;
|
|
2622
|
-
let r =
|
|
2622
|
+
let r = D(e), i = D(t);
|
|
2623
2623
|
if (r !== i) return [...n, "type"];
|
|
2624
2624
|
let a = e, o = t;
|
|
2625
2625
|
switch (i) {
|
|
2626
|
-
case
|
|
2626
|
+
case E.String:
|
|
2627
2627
|
if ((a.minLength ?? 0) < (o.minLength ?? 0)) return [...n, "minLength"];
|
|
2628
2628
|
if ((a.maxLength ?? Infinity) > (o.maxLength ?? Infinity)) return [...n, "maxLength"];
|
|
2629
2629
|
if (a.pattern !== o.pattern && o.pattern) return [...n, "pattern"];
|
|
2630
2630
|
if (a.format !== o.format && o.format) return [...n, "format"];
|
|
2631
2631
|
break;
|
|
2632
|
-
case
|
|
2632
|
+
case E.Numeric:
|
|
2633
2633
|
if ((a.minimum ?? a.exclusiveMinimum ?? -Infinity) < (o.minimum ?? o.exclusiveMinimum ?? -Infinity)) return [...n, o.exclusiveMinimum == null ? "minimum" : "exclusiveMinimum"];
|
|
2634
2634
|
if ((a.maximum ?? a.exclusiveMaximum ?? Infinity) > (o.maximum ?? o.exclusiveMaximum ?? Infinity)) return [...n, o.exclusiveMaximum == null ? "maximum" : "exclusiveMaximum"];
|
|
2635
2635
|
if (a.multipleOf !== o.multipleOf && o.multipleOf != null) return [...n, "multipleOf"];
|
|
2636
2636
|
break;
|
|
2637
|
-
case
|
|
2637
|
+
case E.Array:
|
|
2638
2638
|
if ((a.minItems ?? 0) < (o.minItems ?? 0)) return [...n, "minItems"];
|
|
2639
2639
|
if ((a.maxItems ?? Infinity) > (o.maxItems ?? Infinity)) return [...n, "maxItems"];
|
|
2640
2640
|
if (!a.uniqueItems && o.uniqueItems) return [...n, "uniqueItems"];
|
|
2641
2641
|
break;
|
|
2642
|
-
case
|
|
2642
|
+
case E.Object: {
|
|
2643
2643
|
let e = new Set(a.required ?? []);
|
|
2644
2644
|
if ((o.required ?? []).some((t) => !e.has(t))) return [...n, "required"];
|
|
2645
2645
|
if ((a.minProperties ?? 0) < (o.minProperties ?? 0)) return [...n, "minProperties"];
|
|
2646
2646
|
if ((a.maxProperties ?? Infinity) > (o.maxProperties ?? Infinity)) return [...n, "maxProperties"];
|
|
2647
2647
|
break;
|
|
2648
2648
|
}
|
|
2649
|
-
case
|
|
2649
|
+
case E.EnumOrConst: return [...n, o.const == null ? "enum" : "const"];
|
|
2650
2650
|
}
|
|
2651
2651
|
return n;
|
|
2652
2652
|
}
|
|
@@ -2657,7 +2657,7 @@ var fr = class e {
|
|
|
2657
2657
|
this.extendsSchemaClasses = Object.freeze([...e]);
|
|
2658
2658
|
}
|
|
2659
2659
|
tryCompiledExtendsSchema(e, t) {
|
|
2660
|
-
for (let n of this.extendsSchemaClasses) if (n.isMatch(e)) return new n(
|
|
2660
|
+
for (let n of this.extendsSchemaClasses) if (n.isMatch(e)) return new n(we(), e, t);
|
|
2661
2661
|
return null;
|
|
2662
2662
|
}
|
|
2663
2663
|
isExtendsSchema(e) {
|
|
@@ -2667,7 +2667,7 @@ var fr = class e {
|
|
|
2667
2667
|
calculate(t, n) {
|
|
2668
2668
|
let r = !(t instanceof this.findMatchedClass(t, n)), i = 0, a;
|
|
2669
2669
|
a = r ? n.compare(t) : t.compare(n);
|
|
2670
|
-
for (let t of a) r && (t = e.swap(t)), i |=
|
|
2670
|
+
for (let t of a) r && (t = e.swap(t)), i |= Fe(t);
|
|
2671
2671
|
return i;
|
|
2672
2672
|
}
|
|
2673
2673
|
equals(e, t) {
|
|
@@ -2679,8 +2679,8 @@ var fr = class e {
|
|
|
2679
2679
|
}
|
|
2680
2680
|
static swap(e) {
|
|
2681
2681
|
switch (e) {
|
|
2682
|
-
case
|
|
2683
|
-
case
|
|
2682
|
+
case g.Containing: return g.ContainedBy;
|
|
2683
|
+
case g.ContainedBy: return g.Containing;
|
|
2684
2684
|
default: return e;
|
|
2685
2685
|
}
|
|
2686
2686
|
}
|
|
@@ -2691,12 +2691,12 @@ function pr(e, t, n = !1) {
|
|
|
2691
2691
|
let r = t(e);
|
|
2692
2692
|
if (Array.isArray(r)) {
|
|
2693
2693
|
let e = [];
|
|
2694
|
-
throw hr(e, r, "$"), new
|
|
2694
|
+
throw hr(e, r, "$"), new Je(e);
|
|
2695
2695
|
}
|
|
2696
2696
|
let { schema: i, warns: a } = r;
|
|
2697
2697
|
if (n && a.length > 0) {
|
|
2698
2698
|
console.warn(`found ${a.length} warns after compile schema`);
|
|
2699
|
-
for (let e of a) console.warn(
|
|
2699
|
+
for (let e of a) console.warn(Xe(e));
|
|
2700
2700
|
}
|
|
2701
2701
|
return i;
|
|
2702
2702
|
}
|
|
@@ -2704,14 +2704,14 @@ function mr(e, t, n, r = !1) {
|
|
|
2704
2704
|
let i = n(e), a = n(t);
|
|
2705
2705
|
if (Array.isArray(i) || Array.isArray(a)) {
|
|
2706
2706
|
let e = [];
|
|
2707
|
-
throw Array.isArray(i) && hr(e, i, "$1"), Array.isArray(a) && hr(e, a, "$2"), new
|
|
2707
|
+
throw Array.isArray(i) && hr(e, i, "$1"), Array.isArray(a) && hr(e, a, "$2"), new Je(e);
|
|
2708
2708
|
}
|
|
2709
2709
|
let { schema: o, warns: s } = i, { schema: c, warns: l } = a;
|
|
2710
2710
|
if (r) {
|
|
2711
2711
|
s.length > 0 && console.warn(`found ${s.length} warns after compile superSchema`);
|
|
2712
|
-
for (let e of s) console.warn(
|
|
2712
|
+
for (let e of s) console.warn(Xe(e));
|
|
2713
2713
|
l.length > 0 && console.warn(`found ${l.length} warns after compile subSchema`);
|
|
2714
|
-
for (let e of l) console.warn(
|
|
2714
|
+
for (let e of l) console.warn(Xe(e));
|
|
2715
2715
|
}
|
|
2716
2716
|
return [o, c];
|
|
2717
2717
|
}
|
|
@@ -2736,7 +2736,7 @@ function _r({ extendsSchemaClasses: e, delegate: t } = {}) {
|
|
|
2736
2736
|
return Object.freeze({
|
|
2737
2737
|
compile: (e, r, i) => pr(e, (e) => nn(e, n, r, t), i),
|
|
2738
2738
|
isSubset: (e, r, i = !1) => {
|
|
2739
|
-
let [a, o] = mr(e, r, (e) => nn(e, n, void 0, t), i), { errorPath: s, expression: c } = or(n, a, o), l =
|
|
2739
|
+
let [a, o] = mr(e, r, (e) => nn(e, n, void 0, t), i), { errorPath: s, expression: c } = or(n, a, o), l = Ae(c) || Me(c), u = je(c) || Pe(c) || Ne(c);
|
|
2740
2740
|
return l && !u ? { result: gr.True } : !l && u ? {
|
|
2741
2741
|
errorPath: s,
|
|
2742
2742
|
result: gr.False
|
|
@@ -2767,7 +2767,7 @@ var Er = class e {
|
|
|
2767
2767
|
this.id = e, this.value = t, this.context = Tr(n);
|
|
2768
2768
|
}
|
|
2769
2769
|
compare(e) {
|
|
2770
|
-
return
|
|
2770
|
+
return mt(e) && D(e) === E.Any ? [g.ContainedBy] : this.compareImpl(e);
|
|
2771
2771
|
}
|
|
2772
2772
|
}, Dr = class e extends Er {
|
|
2773
2773
|
static isMatch(e) {
|
|
@@ -2779,13 +2779,13 @@ var Er = class e {
|
|
|
2779
2779
|
super(t, n, r);
|
|
2780
2780
|
}
|
|
2781
2781
|
compareImpl(t) {
|
|
2782
|
-
if (Cr(t)) return [
|
|
2782
|
+
if (Cr(t)) return [g.ContainedBy];
|
|
2783
2783
|
if (t instanceof e) {
|
|
2784
|
-
let e = new Set(this.value.enum), n =
|
|
2785
|
-
for (let r of t.value.enum) e.has(r) || (n =
|
|
2786
|
-
return e.size === 0 ? [n] : e.size === this.value.enum.length ? [
|
|
2784
|
+
let e = new Set(this.value.enum), n = g.Equals;
|
|
2785
|
+
for (let r of t.value.enum) e.has(r) || (n = g.ContainedBy), e.delete(r);
|
|
2786
|
+
return e.size === 0 ? [n] : e.size === this.value.enum.length ? [g.Rejection] : [g.Intersection];
|
|
2787
2787
|
}
|
|
2788
|
-
return [
|
|
2788
|
+
return [g.Rejection];
|
|
2789
2789
|
}
|
|
2790
2790
|
equals(t) {
|
|
2791
2791
|
if (t instanceof e) {
|
|
@@ -2807,7 +2807,7 @@ var Er = class e {
|
|
|
2807
2807
|
super(t, n, r);
|
|
2808
2808
|
}
|
|
2809
2809
|
compareImpl(t) {
|
|
2810
|
-
return t instanceof e ? [
|
|
2810
|
+
return t instanceof e ? [g.Equals] : (Er.setError(this, t, "edgeError.binDiffType"), [g.Rejection]);
|
|
2811
2811
|
}
|
|
2812
2812
|
equals(t) {
|
|
2813
2813
|
return t instanceof e;
|
|
@@ -2821,7 +2821,7 @@ var Er = class e {
|
|
|
2821
2821
|
super(t, n, r);
|
|
2822
2822
|
}
|
|
2823
2823
|
compareImpl(t) {
|
|
2824
|
-
return t instanceof e ? [
|
|
2824
|
+
return t instanceof e ? [g.Equals] : (Er.setError(this, t, "edgeError.artifactDiffType"), [g.Rejection]);
|
|
2825
2825
|
}
|
|
2826
2826
|
equals(t) {
|
|
2827
2827
|
return t instanceof e;
|
|
@@ -7248,8 +7248,7 @@ var hf = W(K([G({
|
|
|
7248
7248
|
kind: q("agent"),
|
|
7249
7249
|
code: wd().optional(),
|
|
7250
7250
|
model: J,
|
|
7251
|
-
prompt:
|
|
7252
|
-
system: J,
|
|
7251
|
+
prompt: J,
|
|
7253
7252
|
maxRounds: bd(),
|
|
7254
7253
|
tools: W(G({
|
|
7255
7254
|
id: J,
|
|
@@ -7655,35 +7654,39 @@ function Zf(e) {
|
|
|
7655
7654
|
}
|
|
7656
7655
|
var Qf = /* @__PURE__ */ new WeakMap();
|
|
7657
7656
|
function $f(e, t) {
|
|
7658
|
-
|
|
7657
|
+
return ep(e, t).length == 0;
|
|
7658
|
+
}
|
|
7659
|
+
function ep(e, t) {
|
|
7660
|
+
if (typeof t == "boolean") return t ? [] : ["The schema does not allow any value."];
|
|
7659
7661
|
let n = Zf(t);
|
|
7660
|
-
if (n == null || n.properties != null && Zf(n.properties) == null) return
|
|
7662
|
+
if (n == null || n.properties != null && Zf(n.properties) == null) return ["Invalid output schema."];
|
|
7661
7663
|
try {
|
|
7662
7664
|
let t = Qf.get(n);
|
|
7663
7665
|
if (t == null) {
|
|
7664
7666
|
let e = typeof n.$schema == "string" ? n.$schema : "", r = e.includes("draft-04") ? "4" : e.includes("draft-07") ? "7" : e.includes("2020-12") ? "2020-12" : "2019-09";
|
|
7665
|
-
t = new
|
|
7667
|
+
t = new Se(structuredClone(n), r), Qf.set(n, t);
|
|
7666
7668
|
}
|
|
7667
|
-
|
|
7669
|
+
let r = t.validate(e);
|
|
7670
|
+
return r.valid ? [] : r.errors.map((e) => `${e.instanceLocation || "/"}: ${e.error}`);
|
|
7668
7671
|
} catch {
|
|
7669
|
-
return
|
|
7672
|
+
return ["Output schema validation failed."];
|
|
7670
7673
|
}
|
|
7671
7674
|
}
|
|
7672
7675
|
//#endregion
|
|
7673
7676
|
//#region src/trigger/common/config.ts
|
|
7674
|
-
function
|
|
7677
|
+
function tp(t, n) {
|
|
7675
7678
|
return e(n[t.handle], t.value);
|
|
7676
7679
|
}
|
|
7677
|
-
function tp(e, t) {
|
|
7678
|
-
return Object.fromEntries(e.flatMap((e) => "handle" in e ? [[e.handle, ep(e, t) ?? null]] : []));
|
|
7679
|
-
}
|
|
7680
7680
|
function np(e, t) {
|
|
7681
|
+
return Object.fromEntries(e.flatMap((e) => "handle" in e ? [[e.handle, tp(e, t) ?? null]] : []));
|
|
7682
|
+
}
|
|
7683
|
+
function rp(e, t) {
|
|
7681
7684
|
let n = e.filter((e) => "handle" in e), r = new Set(n.map((e) => e.handle));
|
|
7682
7685
|
if (r.size !== n.length) throw TypeError("Trigger config has duplicate input handles.");
|
|
7683
7686
|
let i = Object.keys(t).find((e) => !r.has(e));
|
|
7684
7687
|
if (i != null) throw TypeError(`Unknown Trigger config input "${i}".`);
|
|
7685
7688
|
let a = Object.fromEntries(n.map((e) => {
|
|
7686
|
-
let n =
|
|
7689
|
+
let n = tp(e, t) ?? null;
|
|
7687
7690
|
if (!(n === null && e.nullable) && !$f(n, e.jsonSchema)) throw TypeError(`Trigger config input "${e.handle}" does not match its declared schema.`);
|
|
7688
7691
|
return [e.handle, n];
|
|
7689
7692
|
}));
|
|
@@ -7692,7 +7695,7 @@ function np(e, t) {
|
|
|
7692
7695
|
}
|
|
7693
7696
|
//#endregion
|
|
7694
7697
|
//#region src/base/common/json.ts
|
|
7695
|
-
function
|
|
7698
|
+
function ip(e) {
|
|
7696
7699
|
if (e === null || typeof e == "boolean" || typeof e == "string") return !0;
|
|
7697
7700
|
if (typeof e == "number") return Number.isFinite(e);
|
|
7698
7701
|
if (typeof e != "object") return !1;
|
|
@@ -7743,54 +7746,54 @@ function rp(e) {
|
|
|
7743
7746
|
}
|
|
7744
7747
|
}
|
|
7745
7748
|
}
|
|
7746
|
-
function
|
|
7749
|
+
function ap(e) {
|
|
7747
7750
|
try {
|
|
7748
|
-
return
|
|
7751
|
+
return ip(e);
|
|
7749
7752
|
} catch {
|
|
7750
7753
|
return !1;
|
|
7751
7754
|
}
|
|
7752
7755
|
}
|
|
7753
|
-
function
|
|
7756
|
+
function op(e) {
|
|
7754
7757
|
try {
|
|
7755
|
-
return typeof e == "object" && !!e && !Array.isArray(e) &&
|
|
7758
|
+
return typeof e == "object" && !!e && !Array.isArray(e) && ip(e);
|
|
7756
7759
|
} catch {
|
|
7757
7760
|
return !1;
|
|
7758
7761
|
}
|
|
7759
7762
|
}
|
|
7760
7763
|
//#endregion
|
|
7761
7764
|
//#region src/trigger/common/integration.ts
|
|
7762
|
-
var
|
|
7763
|
-
function
|
|
7764
|
-
if (!
|
|
7765
|
-
if (typeof e.dedupeKey != "string" || e.dedupeKey.length == 0 ||
|
|
7766
|
-
if (e.outputs !== null && !
|
|
7767
|
-
if (
|
|
7768
|
-
}
|
|
7769
|
-
var
|
|
7765
|
+
var sp = 65536, cp = 5, lp = /^\/v1\/integrations\/(endpoint_[0-9a-f]{32})$/, up = new TextEncoder();
|
|
7766
|
+
function dp(e) {
|
|
7767
|
+
if (!op(e) || e.checkpoint == null || !ap(e.checkpoint) || typeof e.hasMore != "boolean") throw TypeError("Listener page must contain a JSON checkpoint and a boolean hasMore.");
|
|
7768
|
+
if (typeof e.dedupeKey != "string" || e.dedupeKey.length == 0 || up.encode(e.dedupeKey).byteLength > 1024) throw TypeError("Listener page identity must contain between 1 and 1024 bytes.");
|
|
7769
|
+
if (e.outputs !== null && !op(e.outputs)) throw TypeError("Listener page outputs must be an object or null.");
|
|
7770
|
+
if (up.encode(JSON.stringify(e.checkpoint)).byteLength > 65536) throw TypeError("Listener checkpoint exceeds 64 KiB.");
|
|
7771
|
+
}
|
|
7772
|
+
var fp = class extends Error {
|
|
7770
7773
|
constructor(...e) {
|
|
7771
7774
|
super(...e), this.name = "IntegrationConnectionError";
|
|
7772
7775
|
}
|
|
7773
|
-
},
|
|
7776
|
+
}, pp = class extends Error {
|
|
7774
7777
|
constructor(...e) {
|
|
7775
7778
|
super(...e), this.name = "PermanentIntegrationError";
|
|
7776
7779
|
}
|
|
7777
|
-
},
|
|
7780
|
+
}, mp = class extends Error {
|
|
7778
7781
|
constructor(...e) {
|
|
7779
7782
|
super(...e), this.name = "TransientIntegrationError";
|
|
7780
7783
|
}
|
|
7781
7784
|
};
|
|
7782
|
-
function
|
|
7783
|
-
return
|
|
7785
|
+
function hp(e) {
|
|
7786
|
+
return lp.exec(e.pathname)?.[1];
|
|
7784
7787
|
}
|
|
7785
|
-
async function
|
|
7788
|
+
async function gp(e, t) {
|
|
7786
7789
|
if (e == null || e.length == 0) throw TypeError("Integration callback key is required.");
|
|
7787
|
-
let n = await crypto.subtle.importKey("raw",
|
|
7790
|
+
let n = await crypto.subtle.importKey("raw", up.encode(e), {
|
|
7788
7791
|
hash: "SHA-256",
|
|
7789
7792
|
name: "HMAC"
|
|
7790
|
-
}, !1, ["sign"]), r = new Uint8Array(await crypto.subtle.sign("HMAC", n,
|
|
7793
|
+
}, !1, ["sign"]), r = new Uint8Array(await crypto.subtle.sign("HMAC", n, up.encode(`open-flow-integration/v1/${t}`)));
|
|
7791
7794
|
return btoa(String.fromCharCode(...r)).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
|
|
7792
7795
|
}
|
|
7793
|
-
async function
|
|
7796
|
+
async function _p(e, t, n, r) {
|
|
7794
7797
|
if (r == null) return `integration_${crypto.randomUUID().replaceAll("-", "")}`;
|
|
7795
7798
|
let i = JSON.stringify([
|
|
7796
7799
|
1,
|
|
@@ -7800,9 +7803,9 @@ async function gp(e, t, n, r) {
|
|
|
7800
7803
|
n,
|
|
7801
7804
|
r
|
|
7802
7805
|
]);
|
|
7803
|
-
return [...new Uint8Array(await crypto.subtle.digest("SHA-256",
|
|
7806
|
+
return [...new Uint8Array(await crypto.subtle.digest("SHA-256", up.encode(i)))].map((e) => e.toString(16).padStart(2, "0")).join("");
|
|
7804
7807
|
}
|
|
7805
|
-
var
|
|
7808
|
+
var vp = {
|
|
7806
7809
|
config: { source: "primary" },
|
|
7807
7810
|
connectionId: "connection-primary",
|
|
7808
7811
|
definition: {
|
|
@@ -7817,7 +7820,7 @@ var _p = {
|
|
|
7817
7820
|
outcome: "respond",
|
|
7818
7821
|
status: 404
|
|
7819
7822
|
};
|
|
7820
|
-
let t =
|
|
7823
|
+
let t = Cp(e.payload);
|
|
7821
7824
|
if (t?.action == "handshake") return {
|
|
7822
7825
|
body: "accepted",
|
|
7823
7826
|
contentType: "text/plain",
|
|
@@ -7830,7 +7833,7 @@ var _p = {
|
|
|
7830
7833
|
reason: "Conformance delivery was ignored."
|
|
7831
7834
|
};
|
|
7832
7835
|
if (t?.action == "pages") {
|
|
7833
|
-
let n =
|
|
7836
|
+
let n = Cp(e.state?.checkpoint), r = typeof n?.page == "number" ? n.page + 1 : 1, i = typeof t.pages == "number" ? t.pages : 1, a = typeof t.deliveryId == "string" ? t.deliveryId : "pages";
|
|
7834
7837
|
return {
|
|
7835
7838
|
checkpoint: { page: r },
|
|
7836
7839
|
continue: r < i,
|
|
@@ -7843,7 +7846,7 @@ var _p = {
|
|
|
7843
7846
|
} }
|
|
7844
7847
|
};
|
|
7845
7848
|
}
|
|
7846
|
-
let n = typeof t?.deliveryId == "string" ? t.deliveryId : "delivery", r =
|
|
7849
|
+
let n = typeof t?.deliveryId == "string" ? t.deliveryId : "delivery", r = Cp(t?.body) ?? {};
|
|
7847
7850
|
return {
|
|
7848
7851
|
checkpoint: { deliveryId: n },
|
|
7849
7852
|
dedupeKey: n,
|
|
@@ -7856,24 +7859,24 @@ var _p = {
|
|
|
7856
7859
|
};
|
|
7857
7860
|
},
|
|
7858
7861
|
async reconcile(e) {
|
|
7859
|
-
if (e.state == null) throw new
|
|
7862
|
+
if (e.state == null) throw new pp("Conformance Integration state is missing.");
|
|
7860
7863
|
return await e.state.saveSubscription(e.active ? { endpointUrl: e.endpointUrl } : {}, new Date(e.now.getTime() + 6e4)), { outcome: "ready" };
|
|
7861
7864
|
}
|
|
7862
7865
|
},
|
|
7863
7866
|
publishedAt: "2026-08-21T00:00:30.000Z"
|
|
7864
|
-
},
|
|
7867
|
+
}, yp = [
|
|
7865
7868
|
{
|
|
7866
|
-
fixture:
|
|
7869
|
+
fixture: vp,
|
|
7867
7870
|
name: "enforces callback routing, method, body, and handshake boundaries",
|
|
7868
7871
|
async verify(e) {
|
|
7869
7872
|
let t = new URL(e.endpointUrl);
|
|
7870
|
-
await $(await
|
|
7873
|
+
await $(await Sp(e, { url: new URL("/v1/integrations/not-an-endpoint", t).href }), { status: 404 }, "Malformed endpoint"), await $(await Sp(e, { url: new URL("/v1/integrations/endpoint_00000000000000000000000000000000", t).href }), { status: 404 }, "Unknown endpoint"), await $(await Sp(e, { method: "GET" }), {
|
|
7871
7874
|
headers: { allow: "POST" },
|
|
7872
7875
|
status: 405
|
|
7873
|
-
}, "Method"), await $(await
|
|
7876
|
+
}, "Method"), await $(await Sp(e, { body: "{" }), { status: 400 }, "Invalid JSON"), await $(await Sp(e, {
|
|
7874
7877
|
body: "a=1",
|
|
7875
7878
|
headers: { "content-type": "application/x-www-form-urlencoded" }
|
|
7876
|
-
}), { status: 400 }, "Unsupported body format"), await $(await
|
|
7879
|
+
}), { status: 400 }, "Unsupported body format"), await $(await Sp(e, { body: "x".repeat(65537) }), { status: 413 }, "Oversized body"), await $(await Z(e, { action: "handshake" }), {
|
|
7877
7880
|
body: "accepted",
|
|
7878
7881
|
headers: {
|
|
7879
7882
|
"content-type": "text/plain",
|
|
@@ -7884,7 +7887,7 @@ var _p = {
|
|
|
7884
7887
|
}
|
|
7885
7888
|
},
|
|
7886
7889
|
{
|
|
7887
|
-
fixture:
|
|
7890
|
+
fixture: vp,
|
|
7888
7891
|
name: "verifies initializing callbacks before activating the subscription",
|
|
7889
7892
|
async verify(e) {
|
|
7890
7893
|
await $(await Z(e, {
|
|
@@ -7915,7 +7918,7 @@ var _p = {
|
|
|
7915
7918
|
}
|
|
7916
7919
|
},
|
|
7917
7920
|
{
|
|
7918
|
-
fixture:
|
|
7921
|
+
fixture: vp,
|
|
7919
7922
|
name: "deduplicates keyed events and rejects conflicting payloads",
|
|
7920
7923
|
async verify(e) {
|
|
7921
7924
|
await e.reconcile("2026-08-21T00:00:31.000Z");
|
|
@@ -7937,7 +7940,7 @@ var _p = {
|
|
|
7937
7940
|
}
|
|
7938
7941
|
},
|
|
7939
7942
|
{
|
|
7940
|
-
fixture:
|
|
7943
|
+
fixture: vp,
|
|
7941
7944
|
name: "bounds callback pages and resumes from the durable checkpoint",
|
|
7942
7945
|
async verify(e) {
|
|
7943
7946
|
await e.reconcile("2026-08-21T00:00:31.000Z");
|
|
@@ -7952,7 +7955,7 @@ var _p = {
|
|
|
7952
7955
|
}
|
|
7953
7956
|
},
|
|
7954
7957
|
{
|
|
7955
|
-
fixture:
|
|
7958
|
+
fixture: vp,
|
|
7956
7959
|
name: "restores subscription state and callback admission after restart",
|
|
7957
7960
|
async verify(e) {
|
|
7958
7961
|
await e.reconcile("2026-08-21T00:00:31.000Z"), await Z(e, {
|
|
@@ -7977,7 +7980,7 @@ var _p = {
|
|
|
7977
7980
|
}
|
|
7978
7981
|
},
|
|
7979
7982
|
{
|
|
7980
|
-
fixture:
|
|
7983
|
+
fixture: vp,
|
|
7981
7984
|
name: "retires the old runtime before activating a republished target",
|
|
7982
7985
|
async verify(e) {
|
|
7983
7986
|
await e.reconcile("2026-08-21T00:00:31.000Z");
|
|
@@ -7994,7 +7997,7 @@ var _p = {
|
|
|
7994
7997
|
}
|
|
7995
7998
|
},
|
|
7996
7999
|
{
|
|
7997
|
-
fixture:
|
|
8000
|
+
fixture: vp,
|
|
7998
8001
|
name: "retires the remote subscription and rejects later callbacks",
|
|
7999
8002
|
async verify(e) {
|
|
8000
8003
|
await e.reconcile("2026-08-21T00:00:31.000Z"), await e.retire("2026-08-21T00:00:40.000Z"), await $(await Z(e, {
|
|
@@ -8006,8 +8009,8 @@ var _p = {
|
|
|
8006
8009
|
}), { status: 404 }, "Reconciled retirement"), Q((await e.state()).payloads, [], "Retired payloads");
|
|
8007
8010
|
}
|
|
8008
8011
|
}
|
|
8009
|
-
],
|
|
8010
|
-
...
|
|
8012
|
+
], bp = {
|
|
8013
|
+
...vp,
|
|
8011
8014
|
definition: {
|
|
8012
8015
|
initialState: {
|
|
8013
8016
|
checkpoint: null,
|
|
@@ -8046,30 +8049,30 @@ var _p = {
|
|
|
8046
8049
|
}
|
|
8047
8050
|
}
|
|
8048
8051
|
}
|
|
8049
|
-
},
|
|
8052
|
+
}, xp = [
|
|
8050
8053
|
{
|
|
8051
|
-
fixture:
|
|
8054
|
+
fixture: bp,
|
|
8052
8055
|
name: "drains listener pages without a callback and resumes periodic scanning after restart",
|
|
8053
8056
|
async verify(e) {
|
|
8054
8057
|
await e.reconcile("2026-08-21T00:00:31.000Z"), Q((await e.state()).checkpoint, 7, "Drained cursor"), Q((await e.state()).payloads.length, 7, "Drained pages"), await e.restart(), await e.reconcile("2026-08-21T00:01:31.000Z"), Q((await e.state()).checkpoint, 8, "Periodic cursor"), Q((await e.state()).payloads.length, 8, "Periodic pages");
|
|
8055
8058
|
}
|
|
8056
8059
|
},
|
|
8057
8060
|
{
|
|
8058
|
-
fixture:
|
|
8061
|
+
fixture: bp,
|
|
8059
8062
|
name: "persists verified listener wakes across restart without duplicating accepted pages",
|
|
8060
8063
|
async verify(e) {
|
|
8061
8064
|
await e.reconcile("2026-08-21T00:00:31.000Z"), await $(await Z(e, {}, !1), { status: 404 }, "Invalid wake"), await $(await Z(e, {}), { status: 202 }, "First wake"), await $(await Z(e, {}), { status: 202 }, "Duplicate wake"), await e.restart(), await e.reconcile("2026-08-21T00:00:32.000Z"), Q((await e.state()).checkpoint, 7, "Retained cursor"), Q((await e.state()).payloads.length, 7, "Deduplicated pages");
|
|
8062
8065
|
}
|
|
8063
8066
|
},
|
|
8064
8067
|
{
|
|
8065
|
-
fixture:
|
|
8068
|
+
fixture: bp,
|
|
8066
8069
|
name: "preserves a listener cursor on unchanged publication and fences retirement",
|
|
8067
8070
|
async verify(e) {
|
|
8068
8071
|
await e.reconcile("2026-08-21T00:00:31.000Z"), await e.republish("2026-08-21T00:00:40.000Z"), Q((await e.state()).checkpoint, 7, "Republished cursor"), await e.reconcile("2026-08-21T00:01:31.000Z"), Q((await e.state()).payloads.length, 8, "Republished pages"), await e.retire("2026-08-21T00:01:40.000Z"), await $(await Z(e, {}), { status: 404 }, "Retired wake"), await e.reconcile("2026-08-21T00:02:40.000Z"), Q((await e.state()).payloads.length, 8, "Retired pages");
|
|
8069
8072
|
}
|
|
8070
8073
|
}
|
|
8071
8074
|
];
|
|
8072
|
-
function
|
|
8075
|
+
function Sp(e, t = {}) {
|
|
8073
8076
|
return e.request(new Request(t.url ?? e.endpointUrl, {
|
|
8074
8077
|
...t.body == null ? {} : { body: t.body },
|
|
8075
8078
|
headers: {
|
|
@@ -8080,7 +8083,7 @@ function xp(e, t = {}) {
|
|
|
8080
8083
|
}));
|
|
8081
8084
|
}
|
|
8082
8085
|
function Z(e, t, n = !0) {
|
|
8083
|
-
return
|
|
8086
|
+
return Sp(e, {
|
|
8084
8087
|
body: JSON.stringify(t),
|
|
8085
8088
|
headers: n ? { "x-integration-secret": e.callbackSecret } : {}
|
|
8086
8089
|
});
|
|
@@ -8088,7 +8091,7 @@ function Z(e, t, n = !0) {
|
|
|
8088
8091
|
function Q(e, t, n) {
|
|
8089
8092
|
if (!Mr(e, t)) throw Error(`${n}: expected ${JSON.stringify(t)}, received ${JSON.stringify(e)}.`);
|
|
8090
8093
|
}
|
|
8091
|
-
function
|
|
8094
|
+
function Cp(e) {
|
|
8092
8095
|
return typeof e == "object" && e && !Array.isArray(e) ? e : void 0;
|
|
8093
8096
|
}
|
|
8094
8097
|
async function $(e, t, n) {
|
|
@@ -8096,4 +8099,4 @@ async function $(e, t, n) {
|
|
|
8096
8099
|
for (let [r, i] of Object.entries(t.headers ?? {})) Q(e.headers.get(r), i, `${n} header ${r}`);
|
|
8097
8100
|
}
|
|
8098
8101
|
//#endregion
|
|
8099
|
-
export {
|
|
8102
|
+
export { fp as IntegrationConnectionError, pp as PermanentIntegrationError, mp as TransientIntegrationError, gp as integrationCallbackSecret, yp as integrationConformanceCases, hp as integrationEndpointId, _p as integrationOccurrenceId, xp as listenerConformanceCases, sp as maximumIntegrationBodyBytes, cp as maximumIntegrationDeliveryPages, rp as resolveTriggerConfig, np as triggerConfigValues, dp as validateListenerPage };
|