@prisma/config 6.6.0-dev.9 → 6.6.0-dev.91
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/dist/index.d.ts +106 -33
- package/dist/index.js +937 -917
- package/package.json +3 -3
package/dist/index.js
CHANGED
|
@@ -5,10 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
|
5
5
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
6
6
|
var __getProtoOf = Object.getPrototypeOf;
|
|
7
7
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
8
|
-
var __typeError = (msg) => {
|
|
9
|
-
throw TypeError(msg);
|
|
10
|
-
};
|
|
11
|
-
var __defNormalProp = (obj, key, value3) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value: value3 }) : obj[key] = value3;
|
|
12
8
|
var __export = (target, all5) => {
|
|
13
9
|
for (var name in all5)
|
|
14
10
|
__defProp(target, name, { get: all5[name], enumerable: true });
|
|
@@ -30,11 +26,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
|
|
|
30
26
|
mod
|
|
31
27
|
));
|
|
32
28
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
33
|
-
var __publicField = (obj, key, value3) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value3);
|
|
34
|
-
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
|
|
35
|
-
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
|
|
36
|
-
var __privateAdd = (obj, member, value3) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value3);
|
|
37
|
-
var __privateSet = (obj, member, value3, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value3) : member.set(obj, value3), value3);
|
|
38
29
|
|
|
39
30
|
// src/index.ts
|
|
40
31
|
var index_exports = {};
|
|
@@ -231,6 +222,129 @@ function safeStringify(value3, indent = 2) {
|
|
|
231
222
|
);
|
|
232
223
|
}
|
|
233
224
|
|
|
225
|
+
// ../driver-adapter-utils/dist/index.mjs
|
|
226
|
+
function isDriverAdapterError(error) {
|
|
227
|
+
return error["name"] === "DriverAdapterError" && typeof error["cause"] === "object";
|
|
228
|
+
}
|
|
229
|
+
function ok(value3) {
|
|
230
|
+
return {
|
|
231
|
+
ok: true,
|
|
232
|
+
value: value3,
|
|
233
|
+
map(fn) {
|
|
234
|
+
return ok(fn(value3));
|
|
235
|
+
},
|
|
236
|
+
flatMap(fn) {
|
|
237
|
+
return fn(value3);
|
|
238
|
+
}
|
|
239
|
+
};
|
|
240
|
+
}
|
|
241
|
+
function err(error) {
|
|
242
|
+
return {
|
|
243
|
+
ok: false,
|
|
244
|
+
error,
|
|
245
|
+
map() {
|
|
246
|
+
return err(error);
|
|
247
|
+
},
|
|
248
|
+
flatMap() {
|
|
249
|
+
return err(error);
|
|
250
|
+
}
|
|
251
|
+
};
|
|
252
|
+
}
|
|
253
|
+
var ErrorRegistryInternal = class {
|
|
254
|
+
registeredErrors = [];
|
|
255
|
+
consumeError(id) {
|
|
256
|
+
return this.registeredErrors[id];
|
|
257
|
+
}
|
|
258
|
+
registerNewError(error) {
|
|
259
|
+
let i = 0;
|
|
260
|
+
while (this.registeredErrors[i] !== void 0) {
|
|
261
|
+
i++;
|
|
262
|
+
}
|
|
263
|
+
this.registeredErrors[i] = { error };
|
|
264
|
+
return i;
|
|
265
|
+
}
|
|
266
|
+
};
|
|
267
|
+
var bindMigrationAwareSqlAdapterFactory = (adapterFactory) => {
|
|
268
|
+
const errorRegistry = new ErrorRegistryInternal();
|
|
269
|
+
const boundFactory = {
|
|
270
|
+
adapterName: adapterFactory.adapterName,
|
|
271
|
+
provider: adapterFactory.provider,
|
|
272
|
+
errorRegistry,
|
|
273
|
+
connect: async (...args2) => {
|
|
274
|
+
const ctx = await wrapAsync(errorRegistry, adapterFactory.connect.bind(adapterFactory))(...args2);
|
|
275
|
+
return ctx.map((ctx2) => bindAdapter(ctx2, errorRegistry));
|
|
276
|
+
},
|
|
277
|
+
connectToShadowDb: async (...args2) => {
|
|
278
|
+
const ctx = await wrapAsync(errorRegistry, adapterFactory.connectToShadowDb.bind(adapterFactory))(...args2);
|
|
279
|
+
return ctx.map((ctx2) => bindAdapter(ctx2, errorRegistry));
|
|
280
|
+
}
|
|
281
|
+
};
|
|
282
|
+
return boundFactory;
|
|
283
|
+
};
|
|
284
|
+
var bindAdapter = (adapter4, errorRegistry = new ErrorRegistryInternal()) => {
|
|
285
|
+
const boundAdapter = {
|
|
286
|
+
adapterName: adapter4.adapterName,
|
|
287
|
+
errorRegistry,
|
|
288
|
+
queryRaw: wrapAsync(errorRegistry, adapter4.queryRaw.bind(adapter4)),
|
|
289
|
+
executeRaw: wrapAsync(errorRegistry, adapter4.executeRaw.bind(adapter4)),
|
|
290
|
+
executeScript: wrapAsync(errorRegistry, adapter4.executeScript.bind(adapter4)),
|
|
291
|
+
dispose: wrapAsync(errorRegistry, adapter4.dispose.bind(adapter4)),
|
|
292
|
+
provider: adapter4.provider,
|
|
293
|
+
startTransaction: async (...args2) => {
|
|
294
|
+
const ctx = await wrapAsync(errorRegistry, adapter4.startTransaction.bind(adapter4))(...args2);
|
|
295
|
+
return ctx.map((ctx2) => bindTransaction(errorRegistry, ctx2));
|
|
296
|
+
}
|
|
297
|
+
};
|
|
298
|
+
if (adapter4.getConnectionInfo) {
|
|
299
|
+
boundAdapter.getConnectionInfo = wrapSync(errorRegistry, adapter4.getConnectionInfo.bind(adapter4));
|
|
300
|
+
}
|
|
301
|
+
return boundAdapter;
|
|
302
|
+
};
|
|
303
|
+
var bindTransaction = (errorRegistry, transaction) => {
|
|
304
|
+
return {
|
|
305
|
+
adapterName: transaction.adapterName,
|
|
306
|
+
provider: transaction.provider,
|
|
307
|
+
options: transaction.options,
|
|
308
|
+
queryRaw: wrapAsync(errorRegistry, transaction.queryRaw.bind(transaction)),
|
|
309
|
+
executeRaw: wrapAsync(errorRegistry, transaction.executeRaw.bind(transaction)),
|
|
310
|
+
commit: wrapAsync(errorRegistry, transaction.commit.bind(transaction)),
|
|
311
|
+
rollback: wrapAsync(errorRegistry, transaction.rollback.bind(transaction))
|
|
312
|
+
};
|
|
313
|
+
};
|
|
314
|
+
function wrapAsync(registry, fn) {
|
|
315
|
+
return async (...args2) => {
|
|
316
|
+
try {
|
|
317
|
+
return ok(await fn(...args2));
|
|
318
|
+
} catch (error) {
|
|
319
|
+
if (isDriverAdapterError(error)) {
|
|
320
|
+
return err(error.cause);
|
|
321
|
+
}
|
|
322
|
+
const id = registry.registerNewError(error);
|
|
323
|
+
return err({ kind: "GenericJs", id });
|
|
324
|
+
}
|
|
325
|
+
};
|
|
326
|
+
}
|
|
327
|
+
function wrapSync(registry, fn) {
|
|
328
|
+
return (...args2) => {
|
|
329
|
+
try {
|
|
330
|
+
return ok(fn(...args2));
|
|
331
|
+
} catch (error) {
|
|
332
|
+
if (isDriverAdapterError(error)) {
|
|
333
|
+
return err(error.cause);
|
|
334
|
+
}
|
|
335
|
+
const id = registry.registerNewError(error);
|
|
336
|
+
return err({ kind: "GenericJs", id });
|
|
337
|
+
}
|
|
338
|
+
};
|
|
339
|
+
}
|
|
340
|
+
var mockAdapterErrors = {
|
|
341
|
+
queryRaw: new Error("Not implemented: queryRaw"),
|
|
342
|
+
executeRaw: new Error("Not implemented: executeRaw"),
|
|
343
|
+
startTransaction: new Error("Not implemented: startTransaction"),
|
|
344
|
+
executeScript: new Error("Not implemented: executeScript"),
|
|
345
|
+
dispose: new Error("Not implemented: dispose")
|
|
346
|
+
};
|
|
347
|
+
|
|
234
348
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/Function.js
|
|
235
349
|
var isFunction = (input) => typeof input === "function";
|
|
236
350
|
var dual = function(arity, body) {
|
|
@@ -453,14 +567,9 @@ var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue
|
|
|
453
567
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/Utils.js
|
|
454
568
|
var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
|
|
455
569
|
var isGenKind = (u) => isObject(u) && GenKindTypeId in u;
|
|
456
|
-
var _a;
|
|
457
570
|
var GenKindImpl = class {
|
|
571
|
+
value;
|
|
458
572
|
constructor(value3) {
|
|
459
|
-
__publicField(this, "value");
|
|
460
|
-
/**
|
|
461
|
-
* @since 2.0.0
|
|
462
|
-
*/
|
|
463
|
-
__publicField(this, _a, GenKindTypeId);
|
|
464
573
|
this.value = value3;
|
|
465
574
|
}
|
|
466
575
|
/**
|
|
@@ -490,14 +599,18 @@ var GenKindImpl = class {
|
|
|
490
599
|
/**
|
|
491
600
|
* @since 2.0.0
|
|
492
601
|
*/
|
|
493
|
-
[
|
|
602
|
+
[GenKindTypeId] = GenKindTypeId;
|
|
603
|
+
/**
|
|
604
|
+
* @since 2.0.0
|
|
605
|
+
*/
|
|
606
|
+
[Symbol.iterator]() {
|
|
494
607
|
return new SingleShotGen(this);
|
|
495
608
|
}
|
|
496
609
|
};
|
|
497
610
|
var SingleShotGen = class _SingleShotGen {
|
|
611
|
+
self;
|
|
612
|
+
called = false;
|
|
498
613
|
constructor(self) {
|
|
499
|
-
__publicField(this, "self");
|
|
500
|
-
__publicField(this, "called", false);
|
|
501
614
|
this.self = self;
|
|
502
615
|
}
|
|
503
616
|
/**
|
|
@@ -548,8 +661,8 @@ var MUL_LO = 1284865837 >>> 0;
|
|
|
548
661
|
var BIT_53 = 9007199254740992;
|
|
549
662
|
var BIT_27 = 134217728;
|
|
550
663
|
var PCGRandom = class {
|
|
664
|
+
_state;
|
|
551
665
|
constructor(seedHi, seedLo, incHi, incLo) {
|
|
552
|
-
__publicField(this, "_state");
|
|
553
666
|
if (isNullable(seedLo) && isNullable(seedHi)) {
|
|
554
667
|
seedLo = Math.random() * 4294967295 >>> 0;
|
|
555
668
|
seedHi = 0;
|
|
@@ -658,23 +771,21 @@ function add64(out, aHi, aLo, bHi, bLo) {
|
|
|
658
771
|
out[1] = lo;
|
|
659
772
|
}
|
|
660
773
|
var YieldWrapTypeId = /* @__PURE__ */ Symbol.for("effect/Utils/YieldWrap");
|
|
661
|
-
var _value;
|
|
662
774
|
var YieldWrap = class {
|
|
775
|
+
/**
|
|
776
|
+
* @since 3.0.6
|
|
777
|
+
*/
|
|
778
|
+
#value;
|
|
663
779
|
constructor(value3) {
|
|
664
|
-
|
|
665
|
-
* @since 3.0.6
|
|
666
|
-
*/
|
|
667
|
-
__privateAdd(this, _value);
|
|
668
|
-
__privateSet(this, _value, value3);
|
|
780
|
+
this.#value = value3;
|
|
669
781
|
}
|
|
670
782
|
/**
|
|
671
783
|
* @since 3.0.6
|
|
672
784
|
*/
|
|
673
785
|
[YieldWrapTypeId]() {
|
|
674
|
-
return
|
|
786
|
+
return this.#value;
|
|
675
787
|
}
|
|
676
788
|
};
|
|
677
|
-
_value = new WeakMap();
|
|
678
789
|
function yieldWrapGet(self) {
|
|
679
790
|
if (typeof self === "object" && self !== null && YieldWrapTypeId in self) {
|
|
680
791
|
return self[YieldWrapTypeId]();
|
|
@@ -1576,8 +1687,8 @@ var PreconditionFailure = class _PreconditionFailure extends Error {
|
|
|
1576
1687
|
this.interruptExecution = interruptExecution;
|
|
1577
1688
|
this.footprint = _PreconditionFailure.SharedFootPrint;
|
|
1578
1689
|
}
|
|
1579
|
-
static isFailure(
|
|
1580
|
-
return
|
|
1690
|
+
static isFailure(err2) {
|
|
1691
|
+
return err2 != null && err2.footprint === _PreconditionFailure.SharedFootPrint;
|
|
1581
1692
|
}
|
|
1582
1693
|
};
|
|
1583
1694
|
PreconditionFailure.SharedFootPrint = Symbol.for("fast-check/PreconditionFailure");
|
|
@@ -1910,7 +2021,7 @@ var NoShrinkArbitrary = class extends Arbitrary {
|
|
|
1910
2021
|
canShrinkWithoutContext(value3) {
|
|
1911
2022
|
return this.arb.canShrinkWithoutContext(value3);
|
|
1912
2023
|
}
|
|
1913
|
-
shrink(
|
|
2024
|
+
shrink(_value, _context) {
|
|
1914
2025
|
return Stream.nil();
|
|
1915
2026
|
}
|
|
1916
2027
|
noShrink() {
|
|
@@ -1942,7 +2053,7 @@ var ApplySymbol = Symbol("apply");
|
|
|
1942
2053
|
function safeExtractApply(f) {
|
|
1943
2054
|
try {
|
|
1944
2055
|
return f.apply;
|
|
1945
|
-
} catch (
|
|
2056
|
+
} catch (err2) {
|
|
1946
2057
|
return void 0;
|
|
1947
2058
|
}
|
|
1948
2059
|
}
|
|
@@ -1980,42 +2091,42 @@ var untouchedEvery = Array.prototype.every;
|
|
|
1980
2091
|
function extractIndexOf(instance) {
|
|
1981
2092
|
try {
|
|
1982
2093
|
return instance.indexOf;
|
|
1983
|
-
} catch (
|
|
2094
|
+
} catch (err2) {
|
|
1984
2095
|
return void 0;
|
|
1985
2096
|
}
|
|
1986
2097
|
}
|
|
1987
2098
|
function extractJoin(instance) {
|
|
1988
2099
|
try {
|
|
1989
2100
|
return instance.join;
|
|
1990
|
-
} catch (
|
|
2101
|
+
} catch (err2) {
|
|
1991
2102
|
return void 0;
|
|
1992
2103
|
}
|
|
1993
2104
|
}
|
|
1994
2105
|
function extractMap(instance) {
|
|
1995
2106
|
try {
|
|
1996
2107
|
return instance.map;
|
|
1997
|
-
} catch (
|
|
2108
|
+
} catch (err2) {
|
|
1998
2109
|
return void 0;
|
|
1999
2110
|
}
|
|
2000
2111
|
}
|
|
2001
2112
|
function extractFilter(instance) {
|
|
2002
2113
|
try {
|
|
2003
2114
|
return instance.filter;
|
|
2004
|
-
} catch (
|
|
2115
|
+
} catch (err2) {
|
|
2005
2116
|
return void 0;
|
|
2006
2117
|
}
|
|
2007
2118
|
}
|
|
2008
2119
|
function extractPush(instance) {
|
|
2009
2120
|
try {
|
|
2010
2121
|
return instance.push;
|
|
2011
|
-
} catch (
|
|
2122
|
+
} catch (err2) {
|
|
2012
2123
|
return void 0;
|
|
2013
2124
|
}
|
|
2014
2125
|
}
|
|
2015
2126
|
function extractSlice(instance) {
|
|
2016
2127
|
try {
|
|
2017
2128
|
return instance.slice;
|
|
2018
|
-
} catch (
|
|
2129
|
+
} catch (err2) {
|
|
2019
2130
|
return void 0;
|
|
2020
2131
|
}
|
|
2021
2132
|
}
|
|
@@ -2060,14 +2171,14 @@ var untouchedToISOString = Date.prototype.toISOString;
|
|
|
2060
2171
|
function extractGetTime(instance) {
|
|
2061
2172
|
try {
|
|
2062
2173
|
return instance.getTime;
|
|
2063
|
-
} catch (
|
|
2174
|
+
} catch (err2) {
|
|
2064
2175
|
return void 0;
|
|
2065
2176
|
}
|
|
2066
2177
|
}
|
|
2067
2178
|
function extractToISOString(instance) {
|
|
2068
2179
|
try {
|
|
2069
2180
|
return instance.toISOString;
|
|
2070
|
-
} catch (
|
|
2181
|
+
} catch (err2) {
|
|
2071
2182
|
return void 0;
|
|
2072
2183
|
}
|
|
2073
2184
|
}
|
|
@@ -2092,14 +2203,14 @@ var untouchedMapGet = Map.prototype.get;
|
|
|
2092
2203
|
function extractMapSet(instance) {
|
|
2093
2204
|
try {
|
|
2094
2205
|
return instance.set;
|
|
2095
|
-
} catch (
|
|
2206
|
+
} catch (err2) {
|
|
2096
2207
|
return void 0;
|
|
2097
2208
|
}
|
|
2098
2209
|
}
|
|
2099
2210
|
function extractMapGet(instance) {
|
|
2100
2211
|
try {
|
|
2101
2212
|
return instance.get;
|
|
2102
|
-
} catch (
|
|
2213
|
+
} catch (err2) {
|
|
2103
2214
|
return void 0;
|
|
2104
2215
|
}
|
|
2105
2216
|
}
|
|
@@ -2128,14 +2239,14 @@ var untouchedReplace = String.prototype.replace;
|
|
|
2128
2239
|
function extractSplit(instance) {
|
|
2129
2240
|
try {
|
|
2130
2241
|
return instance.split;
|
|
2131
|
-
} catch (
|
|
2242
|
+
} catch (err2) {
|
|
2132
2243
|
return void 0;
|
|
2133
2244
|
}
|
|
2134
2245
|
}
|
|
2135
2246
|
function extractCharCodeAt(instance) {
|
|
2136
2247
|
try {
|
|
2137
2248
|
return instance.charCodeAt;
|
|
2138
|
-
} catch (
|
|
2249
|
+
} catch (err2) {
|
|
2139
2250
|
return void 0;
|
|
2140
2251
|
}
|
|
2141
2252
|
}
|
|
@@ -2155,7 +2266,7 @@ var untouchedNumberToString = Number.prototype.toString;
|
|
|
2155
2266
|
function extractNumberToString(instance) {
|
|
2156
2267
|
try {
|
|
2157
2268
|
return instance.toString;
|
|
2158
|
-
} catch (
|
|
2269
|
+
} catch (err2) {
|
|
2159
2270
|
return void 0;
|
|
2160
2271
|
}
|
|
2161
2272
|
}
|
|
@@ -2264,13 +2375,13 @@ var AsyncProperty = class _AsyncProperty {
|
|
|
2264
2375
|
error: new SError("Property failed by returning false"),
|
|
2265
2376
|
errorMessage: "Error: Property failed by returning false"
|
|
2266
2377
|
};
|
|
2267
|
-
} catch (
|
|
2268
|
-
if (PreconditionFailure.isFailure(
|
|
2269
|
-
return
|
|
2270
|
-
if (
|
|
2271
|
-
return { error:
|
|
2378
|
+
} catch (err2) {
|
|
2379
|
+
if (PreconditionFailure.isFailure(err2))
|
|
2380
|
+
return err2;
|
|
2381
|
+
if (err2 instanceof SError && err2.stack) {
|
|
2382
|
+
return { error: err2, errorMessage: err2.stack };
|
|
2272
2383
|
}
|
|
2273
|
-
return { error:
|
|
2384
|
+
return { error: err2, errorMessage: SString(err2) };
|
|
2274
2385
|
} finally {
|
|
2275
2386
|
if (!dontRunHook) {
|
|
2276
2387
|
await this.afterEachHook();
|
|
@@ -2336,13 +2447,13 @@ var Property = class _Property {
|
|
|
2336
2447
|
error: new SError("Property failed by returning false"),
|
|
2337
2448
|
errorMessage: "Error: Property failed by returning false"
|
|
2338
2449
|
};
|
|
2339
|
-
} catch (
|
|
2340
|
-
if (PreconditionFailure.isFailure(
|
|
2341
|
-
return
|
|
2342
|
-
if (
|
|
2343
|
-
return { error:
|
|
2450
|
+
} catch (err2) {
|
|
2451
|
+
if (PreconditionFailure.isFailure(err2))
|
|
2452
|
+
return err2;
|
|
2453
|
+
if (err2 instanceof SError && err2.stack) {
|
|
2454
|
+
return { error: err2, errorMessage: err2.stack };
|
|
2344
2455
|
}
|
|
2345
|
-
return { error:
|
|
2456
|
+
return { error: err2, errorMessage: SString(err2) };
|
|
2346
2457
|
} finally {
|
|
2347
2458
|
if (!dontRunHook) {
|
|
2348
2459
|
this.afterEachHook();
|
|
@@ -3190,7 +3301,7 @@ function stringifyInternal(value3, previousValues, getAsyncContent) {
|
|
|
3190
3301
|
if (hasToStringMethod(value3)) {
|
|
3191
3302
|
try {
|
|
3192
3303
|
return value3[toStringMethod]();
|
|
3193
|
-
} catch (
|
|
3304
|
+
} catch (err2) {
|
|
3194
3305
|
}
|
|
3195
3306
|
}
|
|
3196
3307
|
switch (safeToString(value3)) {
|
|
@@ -3229,7 +3340,7 @@ function stringifyInternal(value3, previousValues, getAsyncContent) {
|
|
|
3229
3340
|
if (typeof toStringAccessor === "function" && toStringAccessor !== Object.prototype.toString) {
|
|
3230
3341
|
return value3.toString();
|
|
3231
3342
|
}
|
|
3232
|
-
} catch (
|
|
3343
|
+
} catch (err2) {
|
|
3233
3344
|
return "[object Object]";
|
|
3234
3345
|
}
|
|
3235
3346
|
const mapper = (k) => `${k === "__proto__" ? '["__proto__"]' : typeof k === "symbol" ? `[${stringifyInternal(k, currentValues, getAsyncContent)}]` : safeJsonStringify(k)}:${stringifyInternal(value3[k], currentValues, getAsyncContent)}`;
|
|
@@ -3309,7 +3420,7 @@ function stringifyInternal(value3, previousValues, getAsyncContent) {
|
|
|
3309
3420
|
}
|
|
3310
3421
|
try {
|
|
3311
3422
|
return value3.toString();
|
|
3312
|
-
} catch (
|
|
3423
|
+
} catch (_a) {
|
|
3313
3424
|
return safeToString(value3);
|
|
3314
3425
|
}
|
|
3315
3426
|
}
|
|
@@ -4280,9 +4391,9 @@ var SchedulerImplem = class _SchedulerImplem {
|
|
|
4280
4391
|
(thenTaskToBeAwaited ? task.then(() => thenTaskToBeAwaited()) : task).then((data) => {
|
|
4281
4392
|
this.log(schedulingType, taskId, label, metadata, "resolved", data);
|
|
4282
4393
|
return resolve(data);
|
|
4283
|
-
}, (
|
|
4284
|
-
this.log(schedulingType, taskId, label, metadata, "rejected",
|
|
4285
|
-
return reject(
|
|
4394
|
+
}, (err2) => {
|
|
4395
|
+
this.log(schedulingType, taskId, label, metadata, "rejected", err2);
|
|
4396
|
+
return reject(err2);
|
|
4286
4397
|
});
|
|
4287
4398
|
};
|
|
4288
4399
|
});
|
|
@@ -4394,15 +4505,15 @@ var SchedulerImplem = class _SchedulerImplem {
|
|
|
4394
4505
|
clearAndReplaceWatcher();
|
|
4395
4506
|
return ret;
|
|
4396
4507
|
});
|
|
4397
|
-
}, (
|
|
4508
|
+
}, (err2) => {
|
|
4398
4509
|
taskResolved = true;
|
|
4399
4510
|
if (awaiterPromise === null) {
|
|
4400
4511
|
clearAndReplaceWatcher();
|
|
4401
|
-
throw
|
|
4512
|
+
throw err2;
|
|
4402
4513
|
}
|
|
4403
4514
|
return awaiterPromise.then(() => {
|
|
4404
4515
|
clearAndReplaceWatcher();
|
|
4405
|
-
throw
|
|
4516
|
+
throw err2;
|
|
4406
4517
|
});
|
|
4407
4518
|
});
|
|
4408
4519
|
if (this.scheduledTasks.length > 0 && this.scheduledWatchers.length === 0) {
|
|
@@ -4642,15 +4753,15 @@ var getJSONIdentifierAnnotation = /* @__PURE__ */ getAnnotation(JSONIdentifierAn
|
|
|
4642
4753
|
var getJSONIdentifier = (annotated) => orElse2(getJSONIdentifierAnnotation(annotated), () => getIdentifierAnnotation(annotated));
|
|
4643
4754
|
var ParseJsonSchemaId = /* @__PURE__ */ Symbol.for("effect/schema/ParseJson");
|
|
4644
4755
|
var Declaration = class {
|
|
4756
|
+
typeParameters;
|
|
4757
|
+
decodeUnknown;
|
|
4758
|
+
encodeUnknown;
|
|
4759
|
+
annotations;
|
|
4760
|
+
/**
|
|
4761
|
+
* @since 3.10.0
|
|
4762
|
+
*/
|
|
4763
|
+
_tag = "Declaration";
|
|
4645
4764
|
constructor(typeParameters, decodeUnknown3, encodeUnknown3, annotations3 = {}) {
|
|
4646
|
-
__publicField(this, "typeParameters");
|
|
4647
|
-
__publicField(this, "decodeUnknown");
|
|
4648
|
-
__publicField(this, "encodeUnknown");
|
|
4649
|
-
__publicField(this, "annotations");
|
|
4650
|
-
/**
|
|
4651
|
-
* @since 3.10.0
|
|
4652
|
-
*/
|
|
4653
|
-
__publicField(this, "_tag", "Declaration");
|
|
4654
4765
|
this.typeParameters = typeParameters;
|
|
4655
4766
|
this.decodeUnknown = decodeUnknown3;
|
|
4656
4767
|
this.encodeUnknown = encodeUnknown3;
|
|
@@ -4675,13 +4786,13 @@ var Declaration = class {
|
|
|
4675
4786
|
};
|
|
4676
4787
|
var createASTGuard = (tag2) => (ast) => ast._tag === tag2;
|
|
4677
4788
|
var Literal = class {
|
|
4789
|
+
literal;
|
|
4790
|
+
annotations;
|
|
4791
|
+
/**
|
|
4792
|
+
* @since 3.10.0
|
|
4793
|
+
*/
|
|
4794
|
+
_tag = "Literal";
|
|
4678
4795
|
constructor(literal2, annotations3 = {}) {
|
|
4679
|
-
__publicField(this, "literal");
|
|
4680
|
-
__publicField(this, "annotations");
|
|
4681
|
-
/**
|
|
4682
|
-
* @since 3.10.0
|
|
4683
|
-
*/
|
|
4684
|
-
__publicField(this, "_tag", "Literal");
|
|
4685
4796
|
this.literal = literal2;
|
|
4686
4797
|
this.annotations = annotations3;
|
|
4687
4798
|
}
|
|
@@ -4705,13 +4816,13 @@ var Literal = class {
|
|
|
4705
4816
|
var isLiteral = /* @__PURE__ */ createASTGuard("Literal");
|
|
4706
4817
|
var $null = /* @__PURE__ */ new Literal(null);
|
|
4707
4818
|
var UniqueSymbol = class {
|
|
4819
|
+
symbol;
|
|
4820
|
+
annotations;
|
|
4821
|
+
/**
|
|
4822
|
+
* @since 3.10.0
|
|
4823
|
+
*/
|
|
4824
|
+
_tag = "UniqueSymbol";
|
|
4708
4825
|
constructor(symbol3, annotations3 = {}) {
|
|
4709
|
-
__publicField(this, "symbol");
|
|
4710
|
-
__publicField(this, "annotations");
|
|
4711
|
-
/**
|
|
4712
|
-
* @since 3.10.0
|
|
4713
|
-
*/
|
|
4714
|
-
__publicField(this, "_tag", "UniqueSymbol");
|
|
4715
4826
|
this.symbol = symbol3;
|
|
4716
4827
|
this.annotations = annotations3;
|
|
4717
4828
|
}
|
|
@@ -4734,12 +4845,12 @@ var UniqueSymbol = class {
|
|
|
4734
4845
|
};
|
|
4735
4846
|
var isUniqueSymbol = /* @__PURE__ */ createASTGuard("UniqueSymbol");
|
|
4736
4847
|
var UndefinedKeyword = class {
|
|
4848
|
+
annotations;
|
|
4849
|
+
/**
|
|
4850
|
+
* @since 3.10.0
|
|
4851
|
+
*/
|
|
4852
|
+
_tag = "UndefinedKeyword";
|
|
4737
4853
|
constructor(annotations3 = {}) {
|
|
4738
|
-
__publicField(this, "annotations");
|
|
4739
|
-
/**
|
|
4740
|
-
* @since 3.10.0
|
|
4741
|
-
*/
|
|
4742
|
-
__publicField(this, "_tag", "UndefinedKeyword");
|
|
4743
4854
|
this.annotations = annotations3;
|
|
4744
4855
|
}
|
|
4745
4856
|
/**
|
|
@@ -4762,12 +4873,12 @@ var undefinedKeyword = /* @__PURE__ */ new UndefinedKeyword({
|
|
|
4762
4873
|
[TitleAnnotationId]: "undefined"
|
|
4763
4874
|
});
|
|
4764
4875
|
var VoidKeyword = class {
|
|
4876
|
+
annotations;
|
|
4877
|
+
/**
|
|
4878
|
+
* @since 3.10.0
|
|
4879
|
+
*/
|
|
4880
|
+
_tag = "VoidKeyword";
|
|
4765
4881
|
constructor(annotations3 = {}) {
|
|
4766
|
-
__publicField(this, "annotations");
|
|
4767
|
-
/**
|
|
4768
|
-
* @since 3.10.0
|
|
4769
|
-
*/
|
|
4770
|
-
__publicField(this, "_tag", "VoidKeyword");
|
|
4771
4882
|
this.annotations = annotations3;
|
|
4772
4883
|
}
|
|
4773
4884
|
/**
|
|
@@ -4790,12 +4901,12 @@ var voidKeyword = /* @__PURE__ */ new VoidKeyword({
|
|
|
4790
4901
|
[TitleAnnotationId]: "void"
|
|
4791
4902
|
});
|
|
4792
4903
|
var NeverKeyword = class {
|
|
4904
|
+
annotations;
|
|
4905
|
+
/**
|
|
4906
|
+
* @since 3.10.0
|
|
4907
|
+
*/
|
|
4908
|
+
_tag = "NeverKeyword";
|
|
4793
4909
|
constructor(annotations3 = {}) {
|
|
4794
|
-
__publicField(this, "annotations");
|
|
4795
|
-
/**
|
|
4796
|
-
* @since 3.10.0
|
|
4797
|
-
*/
|
|
4798
|
-
__publicField(this, "_tag", "NeverKeyword");
|
|
4799
4910
|
this.annotations = annotations3;
|
|
4800
4911
|
}
|
|
4801
4912
|
/**
|
|
@@ -4819,12 +4930,12 @@ var neverKeyword = /* @__PURE__ */ new NeverKeyword({
|
|
|
4819
4930
|
});
|
|
4820
4931
|
var isNeverKeyword = /* @__PURE__ */ createASTGuard("NeverKeyword");
|
|
4821
4932
|
var UnknownKeyword = class {
|
|
4933
|
+
annotations;
|
|
4934
|
+
/**
|
|
4935
|
+
* @since 3.10.0
|
|
4936
|
+
*/
|
|
4937
|
+
_tag = "UnknownKeyword";
|
|
4822
4938
|
constructor(annotations3 = {}) {
|
|
4823
|
-
__publicField(this, "annotations");
|
|
4824
|
-
/**
|
|
4825
|
-
* @since 3.10.0
|
|
4826
|
-
*/
|
|
4827
|
-
__publicField(this, "_tag", "UnknownKeyword");
|
|
4828
4939
|
this.annotations = annotations3;
|
|
4829
4940
|
}
|
|
4830
4941
|
/**
|
|
@@ -4847,12 +4958,12 @@ var unknownKeyword = /* @__PURE__ */ new UnknownKeyword({
|
|
|
4847
4958
|
[TitleAnnotationId]: "unknown"
|
|
4848
4959
|
});
|
|
4849
4960
|
var AnyKeyword = class {
|
|
4961
|
+
annotations;
|
|
4962
|
+
/**
|
|
4963
|
+
* @since 3.10.0
|
|
4964
|
+
*/
|
|
4965
|
+
_tag = "AnyKeyword";
|
|
4850
4966
|
constructor(annotations3 = {}) {
|
|
4851
|
-
__publicField(this, "annotations");
|
|
4852
|
-
/**
|
|
4853
|
-
* @since 3.10.0
|
|
4854
|
-
*/
|
|
4855
|
-
__publicField(this, "_tag", "AnyKeyword");
|
|
4856
4967
|
this.annotations = annotations3;
|
|
4857
4968
|
}
|
|
4858
4969
|
/**
|
|
@@ -4875,12 +4986,12 @@ var anyKeyword = /* @__PURE__ */ new AnyKeyword({
|
|
|
4875
4986
|
[TitleAnnotationId]: "any"
|
|
4876
4987
|
});
|
|
4877
4988
|
var StringKeyword = class {
|
|
4989
|
+
annotations;
|
|
4990
|
+
/**
|
|
4991
|
+
* @since 3.10.0
|
|
4992
|
+
*/
|
|
4993
|
+
_tag = "StringKeyword";
|
|
4878
4994
|
constructor(annotations3 = {}) {
|
|
4879
|
-
__publicField(this, "annotations");
|
|
4880
|
-
/**
|
|
4881
|
-
* @since 3.10.0
|
|
4882
|
-
*/
|
|
4883
|
-
__publicField(this, "_tag", "StringKeyword");
|
|
4884
4995
|
this.annotations = annotations3;
|
|
4885
4996
|
}
|
|
4886
4997
|
/**
|
|
@@ -4905,12 +5016,12 @@ var stringKeyword = /* @__PURE__ */ new StringKeyword({
|
|
|
4905
5016
|
});
|
|
4906
5017
|
var isStringKeyword = /* @__PURE__ */ createASTGuard("StringKeyword");
|
|
4907
5018
|
var NumberKeyword = class {
|
|
5019
|
+
annotations;
|
|
5020
|
+
/**
|
|
5021
|
+
* @since 3.10.0
|
|
5022
|
+
*/
|
|
5023
|
+
_tag = "NumberKeyword";
|
|
4908
5024
|
constructor(annotations3 = {}) {
|
|
4909
|
-
__publicField(this, "annotations");
|
|
4910
|
-
/**
|
|
4911
|
-
* @since 3.10.0
|
|
4912
|
-
*/
|
|
4913
|
-
__publicField(this, "_tag", "NumberKeyword");
|
|
4914
5025
|
this.annotations = annotations3;
|
|
4915
5026
|
}
|
|
4916
5027
|
/**
|
|
@@ -4935,12 +5046,12 @@ var numberKeyword = /* @__PURE__ */ new NumberKeyword({
|
|
|
4935
5046
|
});
|
|
4936
5047
|
var isNumberKeyword = /* @__PURE__ */ createASTGuard("NumberKeyword");
|
|
4937
5048
|
var BooleanKeyword = class {
|
|
5049
|
+
annotations;
|
|
5050
|
+
/**
|
|
5051
|
+
* @since 3.10.0
|
|
5052
|
+
*/
|
|
5053
|
+
_tag = "BooleanKeyword";
|
|
4938
5054
|
constructor(annotations3 = {}) {
|
|
4939
|
-
__publicField(this, "annotations");
|
|
4940
|
-
/**
|
|
4941
|
-
* @since 3.10.0
|
|
4942
|
-
*/
|
|
4943
|
-
__publicField(this, "_tag", "BooleanKeyword");
|
|
4944
5055
|
this.annotations = annotations3;
|
|
4945
5056
|
}
|
|
4946
5057
|
/**
|
|
@@ -4965,12 +5076,12 @@ var booleanKeyword = /* @__PURE__ */ new BooleanKeyword({
|
|
|
4965
5076
|
});
|
|
4966
5077
|
var isBooleanKeyword = /* @__PURE__ */ createASTGuard("BooleanKeyword");
|
|
4967
5078
|
var BigIntKeyword = class {
|
|
5079
|
+
annotations;
|
|
5080
|
+
/**
|
|
5081
|
+
* @since 3.10.0
|
|
5082
|
+
*/
|
|
5083
|
+
_tag = "BigIntKeyword";
|
|
4968
5084
|
constructor(annotations3 = {}) {
|
|
4969
|
-
__publicField(this, "annotations");
|
|
4970
|
-
/**
|
|
4971
|
-
* @since 3.10.0
|
|
4972
|
-
*/
|
|
4973
|
-
__publicField(this, "_tag", "BigIntKeyword");
|
|
4974
5085
|
this.annotations = annotations3;
|
|
4975
5086
|
}
|
|
4976
5087
|
/**
|
|
@@ -4994,12 +5105,12 @@ var bigIntKeyword = /* @__PURE__ */ new BigIntKeyword({
|
|
|
4994
5105
|
[DescriptionAnnotationId]: "a bigint"
|
|
4995
5106
|
});
|
|
4996
5107
|
var SymbolKeyword = class {
|
|
5108
|
+
annotations;
|
|
5109
|
+
/**
|
|
5110
|
+
* @since 3.10.0
|
|
5111
|
+
*/
|
|
5112
|
+
_tag = "SymbolKeyword";
|
|
4997
5113
|
constructor(annotations3 = {}) {
|
|
4998
|
-
__publicField(this, "annotations");
|
|
4999
|
-
/**
|
|
5000
|
-
* @since 3.10.0
|
|
5001
|
-
*/
|
|
5002
|
-
__publicField(this, "_tag", "SymbolKeyword");
|
|
5003
5114
|
this.annotations = annotations3;
|
|
5004
5115
|
}
|
|
5005
5116
|
/**
|
|
@@ -5024,12 +5135,12 @@ var symbolKeyword = /* @__PURE__ */ new SymbolKeyword({
|
|
|
5024
5135
|
});
|
|
5025
5136
|
var isSymbolKeyword = /* @__PURE__ */ createASTGuard("SymbolKeyword");
|
|
5026
5137
|
var ObjectKeyword = class {
|
|
5138
|
+
annotations;
|
|
5139
|
+
/**
|
|
5140
|
+
* @since 3.10.0
|
|
5141
|
+
*/
|
|
5142
|
+
_tag = "ObjectKeyword";
|
|
5027
5143
|
constructor(annotations3 = {}) {
|
|
5028
|
-
__publicField(this, "annotations");
|
|
5029
|
-
/**
|
|
5030
|
-
* @since 3.10.0
|
|
5031
|
-
*/
|
|
5032
|
-
__publicField(this, "_tag", "ObjectKeyword");
|
|
5033
5144
|
this.annotations = annotations3;
|
|
5034
5145
|
}
|
|
5035
5146
|
/**
|
|
@@ -5053,13 +5164,13 @@ var objectKeyword = /* @__PURE__ */ new ObjectKeyword({
|
|
|
5053
5164
|
[DescriptionAnnotationId]: "an object in the TypeScript meaning, i.e. the `object` type"
|
|
5054
5165
|
});
|
|
5055
5166
|
var Enums = class {
|
|
5167
|
+
enums;
|
|
5168
|
+
annotations;
|
|
5169
|
+
/**
|
|
5170
|
+
* @since 3.10.0
|
|
5171
|
+
*/
|
|
5172
|
+
_tag = "Enums";
|
|
5056
5173
|
constructor(enums, annotations3 = {}) {
|
|
5057
|
-
__publicField(this, "enums");
|
|
5058
|
-
__publicField(this, "annotations");
|
|
5059
|
-
/**
|
|
5060
|
-
* @since 3.10.0
|
|
5061
|
-
*/
|
|
5062
|
-
__publicField(this, "_tag", "Enums");
|
|
5063
5174
|
this.enums = enums;
|
|
5064
5175
|
this.annotations = annotations3;
|
|
5065
5176
|
}
|
|
@@ -5122,12 +5233,12 @@ var templateLiteralSpanTypeToString = (type) => {
|
|
|
5122
5233
|
}
|
|
5123
5234
|
};
|
|
5124
5235
|
var TemplateLiteralSpan = class {
|
|
5236
|
+
literal;
|
|
5237
|
+
/**
|
|
5238
|
+
* @since 3.10.0
|
|
5239
|
+
*/
|
|
5240
|
+
type;
|
|
5125
5241
|
constructor(type, literal2) {
|
|
5126
|
-
__publicField(this, "literal");
|
|
5127
|
-
/**
|
|
5128
|
-
* @since 3.10.0
|
|
5129
|
-
*/
|
|
5130
|
-
__publicField(this, "type");
|
|
5131
5242
|
this.literal = literal2;
|
|
5132
5243
|
if (isTemplateLiteralSpanType(type)) {
|
|
5133
5244
|
this.type = type;
|
|
@@ -5152,14 +5263,14 @@ var TemplateLiteralSpan = class {
|
|
|
5152
5263
|
}
|
|
5153
5264
|
};
|
|
5154
5265
|
var TemplateLiteral = class {
|
|
5266
|
+
head;
|
|
5267
|
+
spans;
|
|
5268
|
+
annotations;
|
|
5269
|
+
/**
|
|
5270
|
+
* @since 3.10.0
|
|
5271
|
+
*/
|
|
5272
|
+
_tag = "TemplateLiteral";
|
|
5155
5273
|
constructor(head4, spans, annotations3 = {}) {
|
|
5156
|
-
__publicField(this, "head");
|
|
5157
|
-
__publicField(this, "spans");
|
|
5158
|
-
__publicField(this, "annotations");
|
|
5159
|
-
/**
|
|
5160
|
-
* @since 3.10.0
|
|
5161
|
-
*/
|
|
5162
|
-
__publicField(this, "_tag", "TemplateLiteral");
|
|
5163
5274
|
this.head = head4;
|
|
5164
5275
|
this.spans = spans;
|
|
5165
5276
|
this.annotations = annotations3;
|
|
@@ -5185,9 +5296,9 @@ var TemplateLiteral = class {
|
|
|
5185
5296
|
var formatTemplateLiteral = (ast) => "`" + ast.head + ast.spans.map(String).join("") + "`";
|
|
5186
5297
|
var isTemplateLiteral = /* @__PURE__ */ createASTGuard("TemplateLiteral");
|
|
5187
5298
|
var Type = class {
|
|
5299
|
+
type;
|
|
5300
|
+
annotations;
|
|
5188
5301
|
constructor(type, annotations3 = {}) {
|
|
5189
|
-
__publicField(this, "type");
|
|
5190
|
-
__publicField(this, "annotations");
|
|
5191
5302
|
this.type = type;
|
|
5192
5303
|
this.annotations = annotations3;
|
|
5193
5304
|
}
|
|
@@ -5208,9 +5319,9 @@ var Type = class {
|
|
|
5208
5319
|
}
|
|
5209
5320
|
};
|
|
5210
5321
|
var OptionalType = class extends Type {
|
|
5322
|
+
isOptional;
|
|
5211
5323
|
constructor(type, isOptional, annotations3 = {}) {
|
|
5212
5324
|
super(type, annotations3);
|
|
5213
|
-
__publicField(this, "isOptional");
|
|
5214
5325
|
this.isOptional = isOptional;
|
|
5215
5326
|
}
|
|
5216
5327
|
/**
|
|
@@ -5232,15 +5343,15 @@ var OptionalType = class extends Type {
|
|
|
5232
5343
|
};
|
|
5233
5344
|
var getRestASTs = (rest) => rest.map((annotatedAST) => annotatedAST.type);
|
|
5234
5345
|
var TupleType = class {
|
|
5346
|
+
elements;
|
|
5347
|
+
rest;
|
|
5348
|
+
isReadonly;
|
|
5349
|
+
annotations;
|
|
5350
|
+
/**
|
|
5351
|
+
* @since 3.10.0
|
|
5352
|
+
*/
|
|
5353
|
+
_tag = "TupleType";
|
|
5235
5354
|
constructor(elements, rest, isReadonly, annotations3 = {}) {
|
|
5236
|
-
__publicField(this, "elements");
|
|
5237
|
-
__publicField(this, "rest");
|
|
5238
|
-
__publicField(this, "isReadonly");
|
|
5239
|
-
__publicField(this, "annotations");
|
|
5240
|
-
/**
|
|
5241
|
-
* @since 3.10.0
|
|
5242
|
-
*/
|
|
5243
|
-
__publicField(this, "_tag", "TupleType");
|
|
5244
5355
|
this.elements = elements;
|
|
5245
5356
|
this.rest = rest;
|
|
5246
5357
|
this.isReadonly = isReadonly;
|
|
@@ -5303,10 +5414,10 @@ var formatTuple = (ast) => {
|
|
|
5303
5414
|
});
|
|
5304
5415
|
};
|
|
5305
5416
|
var PropertySignature = class extends OptionalType {
|
|
5417
|
+
name;
|
|
5418
|
+
isReadonly;
|
|
5306
5419
|
constructor(name, type, isOptional, isReadonly, annotations3) {
|
|
5307
5420
|
super(type, isOptional, annotations3);
|
|
5308
|
-
__publicField(this, "name");
|
|
5309
|
-
__publicField(this, "isReadonly");
|
|
5310
5421
|
this.name = name;
|
|
5311
5422
|
this.isReadonly = isReadonly;
|
|
5312
5423
|
}
|
|
@@ -5341,13 +5452,13 @@ var isParameter = (ast) => {
|
|
|
5341
5452
|
return false;
|
|
5342
5453
|
};
|
|
5343
5454
|
var IndexSignature = class {
|
|
5455
|
+
type;
|
|
5456
|
+
isReadonly;
|
|
5457
|
+
/**
|
|
5458
|
+
* @since 3.10.0
|
|
5459
|
+
*/
|
|
5460
|
+
parameter;
|
|
5344
5461
|
constructor(parameter, type, isReadonly) {
|
|
5345
|
-
__publicField(this, "type");
|
|
5346
|
-
__publicField(this, "isReadonly");
|
|
5347
|
-
/**
|
|
5348
|
-
* @since 3.10.0
|
|
5349
|
-
*/
|
|
5350
|
-
__publicField(this, "parameter");
|
|
5351
5462
|
this.type = type;
|
|
5352
5463
|
this.isReadonly = isReadonly;
|
|
5353
5464
|
if (isParameter(parameter)) {
|
|
@@ -5374,20 +5485,20 @@ var IndexSignature = class {
|
|
|
5374
5485
|
}
|
|
5375
5486
|
};
|
|
5376
5487
|
var TypeLiteral = class {
|
|
5488
|
+
annotations;
|
|
5489
|
+
/**
|
|
5490
|
+
* @since 3.10.0
|
|
5491
|
+
*/
|
|
5492
|
+
_tag = "TypeLiteral";
|
|
5493
|
+
/**
|
|
5494
|
+
* @since 3.10.0
|
|
5495
|
+
*/
|
|
5496
|
+
propertySignatures;
|
|
5497
|
+
/**
|
|
5498
|
+
* @since 3.10.0
|
|
5499
|
+
*/
|
|
5500
|
+
indexSignatures;
|
|
5377
5501
|
constructor(propertySignatures, indexSignatures, annotations3 = {}) {
|
|
5378
|
-
__publicField(this, "annotations");
|
|
5379
|
-
/**
|
|
5380
|
-
* @since 3.10.0
|
|
5381
|
-
*/
|
|
5382
|
-
__publicField(this, "_tag", "TypeLiteral");
|
|
5383
|
-
/**
|
|
5384
|
-
* @since 3.10.0
|
|
5385
|
-
*/
|
|
5386
|
-
__publicField(this, "propertySignatures");
|
|
5387
|
-
/**
|
|
5388
|
-
* @since 3.10.0
|
|
5389
|
-
*/
|
|
5390
|
-
__publicField(this, "indexSignatures");
|
|
5391
5502
|
this.annotations = annotations3;
|
|
5392
5503
|
const keys5 = {};
|
|
5393
5504
|
for (let i = 0; i < propertySignatures.length; i++) {
|
|
@@ -5561,14 +5672,21 @@ var unify = (candidates) => {
|
|
|
5561
5672
|
}
|
|
5562
5673
|
return out;
|
|
5563
5674
|
};
|
|
5564
|
-
var
|
|
5675
|
+
var Union = class _Union {
|
|
5676
|
+
types;
|
|
5677
|
+
annotations;
|
|
5678
|
+
static make = (types, annotations3) => {
|
|
5679
|
+
return isMembers(types) ? new _Union(types, annotations3) : types.length === 1 ? types[0] : neverKeyword;
|
|
5680
|
+
};
|
|
5681
|
+
/** @internal */
|
|
5682
|
+
static unify = (candidates, annotations3) => {
|
|
5683
|
+
return _Union.make(unify(flatten2(candidates)), annotations3);
|
|
5684
|
+
};
|
|
5685
|
+
/**
|
|
5686
|
+
* @since 3.10.0
|
|
5687
|
+
*/
|
|
5688
|
+
_tag = "Union";
|
|
5565
5689
|
constructor(types, annotations3 = {}) {
|
|
5566
|
-
__publicField(this, "types");
|
|
5567
|
-
__publicField(this, "annotations");
|
|
5568
|
-
/**
|
|
5569
|
-
* @since 3.10.0
|
|
5570
|
-
*/
|
|
5571
|
-
__publicField(this, "_tag", "Union");
|
|
5572
5690
|
this.types = types;
|
|
5573
5691
|
this.annotations = annotations3;
|
|
5574
5692
|
}
|
|
@@ -5589,26 +5707,18 @@ var _Union = class _Union {
|
|
|
5589
5707
|
};
|
|
5590
5708
|
}
|
|
5591
5709
|
};
|
|
5592
|
-
__publicField(_Union, "make", (types, annotations3) => {
|
|
5593
|
-
return isMembers(types) ? new _Union(types, annotations3) : types.length === 1 ? types[0] : neverKeyword;
|
|
5594
|
-
});
|
|
5595
|
-
/** @internal */
|
|
5596
|
-
__publicField(_Union, "unify", (candidates, annotations3) => {
|
|
5597
|
-
return _Union.make(unify(flatten2(candidates)), annotations3);
|
|
5598
|
-
});
|
|
5599
|
-
var Union = _Union;
|
|
5600
5710
|
var mapMembers = (members, f) => members.map(f);
|
|
5601
5711
|
var isMembers = (as4) => as4.length > 1;
|
|
5602
5712
|
var isUnion = /* @__PURE__ */ createASTGuard("Union");
|
|
5603
5713
|
var toJSONMemoMap = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Schema/AST/toJSONMemoMap"), () => /* @__PURE__ */ new WeakMap());
|
|
5604
5714
|
var Suspend = class {
|
|
5715
|
+
f;
|
|
5716
|
+
annotations;
|
|
5717
|
+
/**
|
|
5718
|
+
* @since 3.10.0
|
|
5719
|
+
*/
|
|
5720
|
+
_tag = "Suspend";
|
|
5605
5721
|
constructor(f, annotations3 = {}) {
|
|
5606
|
-
__publicField(this, "f");
|
|
5607
|
-
__publicField(this, "annotations");
|
|
5608
|
-
/**
|
|
5609
|
-
* @since 3.10.0
|
|
5610
|
-
*/
|
|
5611
|
-
__publicField(this, "_tag", "Suspend");
|
|
5612
5722
|
this.f = f;
|
|
5613
5723
|
this.annotations = annotations3;
|
|
5614
5724
|
this.f = memoizeThunk(f);
|
|
@@ -5641,14 +5751,14 @@ var Suspend = class {
|
|
|
5641
5751
|
}
|
|
5642
5752
|
};
|
|
5643
5753
|
var Refinement = class {
|
|
5754
|
+
from;
|
|
5755
|
+
filter;
|
|
5756
|
+
annotations;
|
|
5757
|
+
/**
|
|
5758
|
+
* @since 3.10.0
|
|
5759
|
+
*/
|
|
5760
|
+
_tag = "Refinement";
|
|
5644
5761
|
constructor(from, filter8, annotations3 = {}) {
|
|
5645
|
-
__publicField(this, "from");
|
|
5646
|
-
__publicField(this, "filter");
|
|
5647
|
-
__publicField(this, "annotations");
|
|
5648
|
-
/**
|
|
5649
|
-
* @since 3.10.0
|
|
5650
|
-
*/
|
|
5651
|
-
__publicField(this, "_tag", "Refinement");
|
|
5652
5762
|
this.from = from;
|
|
5653
5763
|
this.filter = filter8;
|
|
5654
5764
|
this.annotations = annotations3;
|
|
@@ -5676,15 +5786,15 @@ var Refinement = class {
|
|
|
5676
5786
|
var isRefinement = /* @__PURE__ */ createASTGuard("Refinement");
|
|
5677
5787
|
var defaultParseOption = {};
|
|
5678
5788
|
var Transformation = class {
|
|
5789
|
+
from;
|
|
5790
|
+
to;
|
|
5791
|
+
transformation;
|
|
5792
|
+
annotations;
|
|
5793
|
+
/**
|
|
5794
|
+
* @since 3.10.0
|
|
5795
|
+
*/
|
|
5796
|
+
_tag = "Transformation";
|
|
5679
5797
|
constructor(from, to, transformation, annotations3 = {}) {
|
|
5680
|
-
__publicField(this, "from");
|
|
5681
|
-
__publicField(this, "to");
|
|
5682
|
-
__publicField(this, "transformation");
|
|
5683
|
-
__publicField(this, "annotations");
|
|
5684
|
-
/**
|
|
5685
|
-
* @since 3.10.0
|
|
5686
|
-
*/
|
|
5687
|
-
__publicField(this, "_tag", "Transformation");
|
|
5688
5798
|
this.from = from;
|
|
5689
5799
|
this.to = to;
|
|
5690
5800
|
this.transformation = transformation;
|
|
@@ -5709,33 +5819,31 @@ var Transformation = class {
|
|
|
5709
5819
|
}
|
|
5710
5820
|
};
|
|
5711
5821
|
var FinalTransformation = class {
|
|
5822
|
+
decode;
|
|
5823
|
+
encode;
|
|
5824
|
+
/**
|
|
5825
|
+
* @since 3.10.0
|
|
5826
|
+
*/
|
|
5827
|
+
_tag = "FinalTransformation";
|
|
5712
5828
|
constructor(decode6, encode5) {
|
|
5713
|
-
__publicField(this, "decode");
|
|
5714
|
-
__publicField(this, "encode");
|
|
5715
|
-
/**
|
|
5716
|
-
* @since 3.10.0
|
|
5717
|
-
*/
|
|
5718
|
-
__publicField(this, "_tag", "FinalTransformation");
|
|
5719
5829
|
this.decode = decode6;
|
|
5720
5830
|
this.encode = encode5;
|
|
5721
5831
|
}
|
|
5722
5832
|
};
|
|
5723
5833
|
var createTransformationGuard = (tag2) => (ast) => ast._tag === tag2;
|
|
5724
5834
|
var ComposeTransformation = class {
|
|
5725
|
-
|
|
5726
|
-
|
|
5727
|
-
|
|
5728
|
-
|
|
5729
|
-
__publicField(this, "_tag", "ComposeTransformation");
|
|
5730
|
-
}
|
|
5835
|
+
/**
|
|
5836
|
+
* @since 3.10.0
|
|
5837
|
+
*/
|
|
5838
|
+
_tag = "ComposeTransformation";
|
|
5731
5839
|
};
|
|
5732
5840
|
var composeTransformation = /* @__PURE__ */ new ComposeTransformation();
|
|
5733
5841
|
var PropertySignatureTransformation = class {
|
|
5842
|
+
from;
|
|
5843
|
+
to;
|
|
5844
|
+
decode;
|
|
5845
|
+
encode;
|
|
5734
5846
|
constructor(from, to, decode6, encode5) {
|
|
5735
|
-
__publicField(this, "from");
|
|
5736
|
-
__publicField(this, "to");
|
|
5737
|
-
__publicField(this, "decode");
|
|
5738
|
-
__publicField(this, "encode");
|
|
5739
5847
|
this.from = from;
|
|
5740
5848
|
this.to = to;
|
|
5741
5849
|
this.decode = decode6;
|
|
@@ -5744,12 +5852,12 @@ var PropertySignatureTransformation = class {
|
|
|
5744
5852
|
};
|
|
5745
5853
|
var isRenamingPropertySignatureTransformation = (t) => t.decode === identity && t.encode === identity;
|
|
5746
5854
|
var TypeLiteralTransformation = class {
|
|
5855
|
+
propertySignatureTransformations;
|
|
5856
|
+
/**
|
|
5857
|
+
* @since 3.10.0
|
|
5858
|
+
*/
|
|
5859
|
+
_tag = "TypeLiteralTransformation";
|
|
5747
5860
|
constructor(propertySignatureTransformations) {
|
|
5748
|
-
__publicField(this, "propertySignatureTransformations");
|
|
5749
|
-
/**
|
|
5750
|
-
* @since 3.10.0
|
|
5751
|
-
*/
|
|
5752
|
-
__publicField(this, "_tag", "TypeLiteralTransformation");
|
|
5753
5861
|
this.propertySignatureTransformations = propertySignatureTransformations;
|
|
5754
5862
|
const fromKeys = {};
|
|
5755
5863
|
const toKeys = {};
|
|
@@ -7530,9 +7638,7 @@ function arraySpliceIn(mutate4, at, v, arr) {
|
|
|
7530
7638
|
|
|
7531
7639
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/internal/hashMap/node.js
|
|
7532
7640
|
var EmptyNode = class _EmptyNode {
|
|
7533
|
-
|
|
7534
|
-
__publicField(this, "_tag", "EmptyNode");
|
|
7535
|
-
}
|
|
7641
|
+
_tag = "EmptyNode";
|
|
7536
7642
|
modify(edit, _shift, f, hash3, key, size7) {
|
|
7537
7643
|
const v = f(none2());
|
|
7538
7644
|
if (isNone2(v)) return new _EmptyNode();
|
|
@@ -7550,12 +7656,12 @@ function canEditNode(node, edit) {
|
|
|
7550
7656
|
return isEmptyNode(node) ? false : edit === node.edit;
|
|
7551
7657
|
}
|
|
7552
7658
|
var LeafNode = class _LeafNode {
|
|
7659
|
+
edit;
|
|
7660
|
+
hash;
|
|
7661
|
+
key;
|
|
7662
|
+
value;
|
|
7663
|
+
_tag = "LeafNode";
|
|
7553
7664
|
constructor(edit, hash3, key, value3) {
|
|
7554
|
-
__publicField(this, "edit");
|
|
7555
|
-
__publicField(this, "hash");
|
|
7556
|
-
__publicField(this, "key");
|
|
7557
|
-
__publicField(this, "value");
|
|
7558
|
-
__publicField(this, "_tag", "LeafNode");
|
|
7559
7665
|
this.edit = edit;
|
|
7560
7666
|
this.hash = hash3;
|
|
7561
7667
|
this.key = key;
|
|
@@ -7583,11 +7689,11 @@ var LeafNode = class _LeafNode {
|
|
|
7583
7689
|
}
|
|
7584
7690
|
};
|
|
7585
7691
|
var CollisionNode = class _CollisionNode {
|
|
7692
|
+
edit;
|
|
7693
|
+
hash;
|
|
7694
|
+
children;
|
|
7695
|
+
_tag = "CollisionNode";
|
|
7586
7696
|
constructor(edit, hash3, children) {
|
|
7587
|
-
__publicField(this, "edit");
|
|
7588
|
-
__publicField(this, "hash");
|
|
7589
|
-
__publicField(this, "children");
|
|
7590
|
-
__publicField(this, "_tag", "CollisionNode");
|
|
7591
7697
|
this.edit = edit;
|
|
7592
7698
|
this.hash = hash3;
|
|
7593
7699
|
this.children = children;
|
|
@@ -7627,11 +7733,11 @@ var CollisionNode = class _CollisionNode {
|
|
|
7627
7733
|
}
|
|
7628
7734
|
};
|
|
7629
7735
|
var IndexedNode = class _IndexedNode {
|
|
7736
|
+
edit;
|
|
7737
|
+
mask;
|
|
7738
|
+
children;
|
|
7739
|
+
_tag = "IndexedNode";
|
|
7630
7740
|
constructor(edit, mask, children) {
|
|
7631
|
-
__publicField(this, "edit");
|
|
7632
|
-
__publicField(this, "mask");
|
|
7633
|
-
__publicField(this, "children");
|
|
7634
|
-
__publicField(this, "_tag", "IndexedNode");
|
|
7635
7741
|
this.edit = edit;
|
|
7636
7742
|
this.mask = mask;
|
|
7637
7743
|
this.children = children;
|
|
@@ -7673,11 +7779,11 @@ var IndexedNode = class _IndexedNode {
|
|
|
7673
7779
|
}
|
|
7674
7780
|
};
|
|
7675
7781
|
var ArrayNode = class _ArrayNode {
|
|
7782
|
+
edit;
|
|
7783
|
+
size;
|
|
7784
|
+
children;
|
|
7785
|
+
_tag = "ArrayNode";
|
|
7676
7786
|
constructor(edit, size7, children) {
|
|
7677
|
-
__publicField(this, "edit");
|
|
7678
|
-
__publicField(this, "size");
|
|
7679
|
-
__publicField(this, "children");
|
|
7680
|
-
__publicField(this, "_tag", "ArrayNode");
|
|
7681
7787
|
this.edit = edit;
|
|
7682
7788
|
this.size = size7;
|
|
7683
7789
|
this.children = children;
|
|
@@ -7828,10 +7934,10 @@ var makeImpl = (editable, edit, root, size7) => {
|
|
|
7828
7934
|
return map15;
|
|
7829
7935
|
};
|
|
7830
7936
|
var HashMapIterator = class _HashMapIterator {
|
|
7937
|
+
map;
|
|
7938
|
+
f;
|
|
7939
|
+
v;
|
|
7831
7940
|
constructor(map15, f) {
|
|
7832
|
-
__publicField(this, "map");
|
|
7833
|
-
__publicField(this, "f");
|
|
7834
|
-
__publicField(this, "v");
|
|
7835
7941
|
this.map = map15;
|
|
7836
7942
|
this.f = f;
|
|
7837
7943
|
this.v = visitLazy(this.map._root, this.f, void 0);
|
|
@@ -8133,15 +8239,12 @@ var OP_NONE = "None";
|
|
|
8133
8239
|
var OP_RUNTIME = "Runtime";
|
|
8134
8240
|
var OP_COMPOSITE = "Composite";
|
|
8135
8241
|
var emptyHash = /* @__PURE__ */ string(`${FiberIdSymbolKey}-${OP_NONE}`);
|
|
8136
|
-
var _a2;
|
|
8137
8242
|
var None = class {
|
|
8138
|
-
|
|
8139
|
-
|
|
8140
|
-
|
|
8141
|
-
|
|
8142
|
-
|
|
8143
|
-
}
|
|
8144
|
-
[(_a2 = FiberIdTypeId, symbol)]() {
|
|
8243
|
+
[FiberIdTypeId] = FiberIdTypeId;
|
|
8244
|
+
_tag = OP_NONE;
|
|
8245
|
+
id = -1;
|
|
8246
|
+
startTimeMillis = -1;
|
|
8247
|
+
[symbol]() {
|
|
8145
8248
|
return emptyHash;
|
|
8146
8249
|
}
|
|
8147
8250
|
[symbol2](that) {
|
|
@@ -8160,17 +8263,16 @@ var None = class {
|
|
|
8160
8263
|
return this.toJSON();
|
|
8161
8264
|
}
|
|
8162
8265
|
};
|
|
8163
|
-
var _a3;
|
|
8164
8266
|
var Runtime = class {
|
|
8267
|
+
id;
|
|
8268
|
+
startTimeMillis;
|
|
8269
|
+
[FiberIdTypeId] = FiberIdTypeId;
|
|
8270
|
+
_tag = OP_RUNTIME;
|
|
8165
8271
|
constructor(id, startTimeMillis) {
|
|
8166
|
-
__publicField(this, "id");
|
|
8167
|
-
__publicField(this, "startTimeMillis");
|
|
8168
|
-
__publicField(this, _a3, FiberIdTypeId);
|
|
8169
|
-
__publicField(this, "_tag", OP_RUNTIME);
|
|
8170
8272
|
this.id = id;
|
|
8171
8273
|
this.startTimeMillis = startTimeMillis;
|
|
8172
8274
|
}
|
|
8173
|
-
[
|
|
8275
|
+
[symbol]() {
|
|
8174
8276
|
return cached(this, string(`${FiberIdSymbolKey}-${this._tag}-${this.id}-${this.startTimeMillis}`));
|
|
8175
8277
|
}
|
|
8176
8278
|
[symbol2](that) {
|
|
@@ -8191,18 +8293,17 @@ var Runtime = class {
|
|
|
8191
8293
|
return this.toJSON();
|
|
8192
8294
|
}
|
|
8193
8295
|
};
|
|
8194
|
-
var _a4;
|
|
8195
8296
|
var Composite = class {
|
|
8297
|
+
left;
|
|
8298
|
+
right;
|
|
8299
|
+
[FiberIdTypeId] = FiberIdTypeId;
|
|
8300
|
+
_tag = OP_COMPOSITE;
|
|
8196
8301
|
constructor(left3, right3) {
|
|
8197
|
-
__publicField(this, "left");
|
|
8198
|
-
__publicField(this, "right");
|
|
8199
|
-
__publicField(this, _a4, FiberIdTypeId);
|
|
8200
|
-
__publicField(this, "_tag", OP_COMPOSITE);
|
|
8201
|
-
__publicField(this, "_hash");
|
|
8202
8302
|
this.left = left3;
|
|
8203
8303
|
this.right = right3;
|
|
8204
8304
|
}
|
|
8205
|
-
|
|
8305
|
+
_hash;
|
|
8306
|
+
[symbol]() {
|
|
8206
8307
|
return pipe(string(`${FiberIdSymbolKey}-${this._tag}`), combine(hash(this.left)), combine(hash(this.right)), cached(this));
|
|
8207
8308
|
}
|
|
8208
8309
|
[symbol2](that) {
|
|
@@ -8995,16 +9096,14 @@ var merge4 = (sequential5, parallel5) => {
|
|
|
8995
9096
|
return cons(parallelCollectionToSequentialCollection(parallel5), sequential5);
|
|
8996
9097
|
};
|
|
8997
9098
|
var EntryTypeId = /* @__PURE__ */ Symbol.for("effect/RequestBlock/Entry");
|
|
8998
|
-
var _a5;
|
|
8999
|
-
_a5 = EntryTypeId;
|
|
9000
9099
|
var EntryImpl = class {
|
|
9100
|
+
request;
|
|
9101
|
+
result;
|
|
9102
|
+
listeners;
|
|
9103
|
+
ownerId;
|
|
9104
|
+
state;
|
|
9105
|
+
[EntryTypeId] = blockedRequestVariance;
|
|
9001
9106
|
constructor(request, result, listeners, ownerId, state) {
|
|
9002
|
-
__publicField(this, "request");
|
|
9003
|
-
__publicField(this, "result");
|
|
9004
|
-
__publicField(this, "listeners");
|
|
9005
|
-
__publicField(this, "ownerId");
|
|
9006
|
-
__publicField(this, "state");
|
|
9007
|
-
__publicField(this, _a5, blockedRequestVariance);
|
|
9008
9107
|
this.request = request;
|
|
9009
9108
|
this.result = result;
|
|
9010
9109
|
this.listeners = listeners;
|
|
@@ -9021,12 +9120,10 @@ var parallelVariance = {
|
|
|
9021
9120
|
/* c8 ignore next */
|
|
9022
9121
|
_R: (_) => _
|
|
9023
9122
|
};
|
|
9024
|
-
var _a6;
|
|
9025
|
-
_a6 = RequestBlockParallelTypeId;
|
|
9026
9123
|
var ParallelImpl = class {
|
|
9124
|
+
map;
|
|
9125
|
+
[RequestBlockParallelTypeId] = parallelVariance;
|
|
9027
9126
|
constructor(map15) {
|
|
9028
|
-
__publicField(this, "map");
|
|
9029
|
-
__publicField(this, _a6, parallelVariance);
|
|
9030
9127
|
this.map = map15;
|
|
9031
9128
|
}
|
|
9032
9129
|
};
|
|
@@ -9044,12 +9141,10 @@ var sequentialVariance = {
|
|
|
9044
9141
|
/* c8 ignore next */
|
|
9045
9142
|
_R: (_) => _
|
|
9046
9143
|
};
|
|
9047
|
-
var _a7;
|
|
9048
|
-
_a7 = SequentialCollectionTypeId;
|
|
9049
9144
|
var SequentialImpl = class {
|
|
9145
|
+
map;
|
|
9146
|
+
[SequentialCollectionTypeId] = sequentialVariance;
|
|
9050
9147
|
constructor(map15) {
|
|
9051
|
-
__publicField(this, "map");
|
|
9052
|
-
__publicField(this, _a7, sequentialVariance);
|
|
9053
9148
|
this.map = map15;
|
|
9054
9149
|
}
|
|
9055
9150
|
};
|
|
@@ -9512,6 +9607,7 @@ ${prefix}}`;
|
|
|
9512
9607
|
return stack;
|
|
9513
9608
|
};
|
|
9514
9609
|
var PrettyError = class _PrettyError extends globalThis.Error {
|
|
9610
|
+
span = void 0;
|
|
9515
9611
|
constructor(originalError) {
|
|
9516
9612
|
const originalErrorIsObject = typeof originalError === "object" && originalError !== null;
|
|
9517
9613
|
const prevLimit = Error.stackTraceLimit;
|
|
@@ -9519,7 +9615,6 @@ var PrettyError = class _PrettyError extends globalThis.Error {
|
|
|
9519
9615
|
super(prettyErrorMessage(originalError), originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined" ? {
|
|
9520
9616
|
cause: new _PrettyError(originalError.cause)
|
|
9521
9617
|
} : void 0);
|
|
9522
|
-
__publicField(this, "span");
|
|
9523
9618
|
if (this.message === "") {
|
|
9524
9619
|
this.message = "An error has occurred";
|
|
9525
9620
|
}
|
|
@@ -9639,9 +9734,9 @@ var done = (effect) => {
|
|
|
9639
9734
|
|
|
9640
9735
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/internal/singleShotGen.js
|
|
9641
9736
|
var SingleShotGen2 = class _SingleShotGen {
|
|
9737
|
+
self;
|
|
9738
|
+
called = false;
|
|
9642
9739
|
constructor(self) {
|
|
9643
|
-
__publicField(this, "self");
|
|
9644
|
-
__publicField(this, "called", false);
|
|
9645
9740
|
this.self = self;
|
|
9646
9741
|
}
|
|
9647
9742
|
next(a) {
|
|
@@ -9681,26 +9776,25 @@ var runRequestBlock = (blockedRequests) => {
|
|
|
9681
9776
|
};
|
|
9682
9777
|
var EffectTypeId2 = /* @__PURE__ */ Symbol.for("effect/Effect");
|
|
9683
9778
|
var RevertFlags = class {
|
|
9779
|
+
patch;
|
|
9780
|
+
op;
|
|
9781
|
+
_op = OP_REVERT_FLAGS;
|
|
9684
9782
|
constructor(patch9, op) {
|
|
9685
|
-
__publicField(this, "patch");
|
|
9686
|
-
__publicField(this, "op");
|
|
9687
|
-
__publicField(this, "_op", OP_REVERT_FLAGS);
|
|
9688
9783
|
this.patch = patch9;
|
|
9689
9784
|
this.op = op;
|
|
9690
9785
|
}
|
|
9691
9786
|
};
|
|
9692
|
-
var _a8;
|
|
9693
9787
|
var EffectPrimitive = class {
|
|
9788
|
+
_op;
|
|
9789
|
+
effect_instruction_i0 = void 0;
|
|
9790
|
+
effect_instruction_i1 = void 0;
|
|
9791
|
+
effect_instruction_i2 = void 0;
|
|
9792
|
+
trace = void 0;
|
|
9793
|
+
[EffectTypeId2] = effectVariance;
|
|
9694
9794
|
constructor(_op) {
|
|
9695
|
-
__publicField(this, "_op");
|
|
9696
|
-
__publicField(this, "effect_instruction_i0");
|
|
9697
|
-
__publicField(this, "effect_instruction_i1");
|
|
9698
|
-
__publicField(this, "effect_instruction_i2");
|
|
9699
|
-
__publicField(this, "trace");
|
|
9700
|
-
__publicField(this, _a8, effectVariance);
|
|
9701
9795
|
this._op = _op;
|
|
9702
9796
|
}
|
|
9703
|
-
[
|
|
9797
|
+
[symbol2](that) {
|
|
9704
9798
|
return this === that;
|
|
9705
9799
|
}
|
|
9706
9800
|
[symbol]() {
|
|
@@ -9728,19 +9822,18 @@ var EffectPrimitive = class {
|
|
|
9728
9822
|
return new SingleShotGen2(new YieldWrap(this));
|
|
9729
9823
|
}
|
|
9730
9824
|
};
|
|
9731
|
-
var _a9;
|
|
9732
9825
|
var EffectPrimitiveFailure = class {
|
|
9826
|
+
_op;
|
|
9827
|
+
effect_instruction_i0 = void 0;
|
|
9828
|
+
effect_instruction_i1 = void 0;
|
|
9829
|
+
effect_instruction_i2 = void 0;
|
|
9830
|
+
trace = void 0;
|
|
9831
|
+
[EffectTypeId2] = effectVariance;
|
|
9733
9832
|
constructor(_op) {
|
|
9734
|
-
__publicField(this, "_op");
|
|
9735
|
-
__publicField(this, "effect_instruction_i0");
|
|
9736
|
-
__publicField(this, "effect_instruction_i1");
|
|
9737
|
-
__publicField(this, "effect_instruction_i2");
|
|
9738
|
-
__publicField(this, "trace");
|
|
9739
|
-
__publicField(this, _a9, effectVariance);
|
|
9740
9833
|
this._op = _op;
|
|
9741
9834
|
this._tag = _op;
|
|
9742
9835
|
}
|
|
9743
|
-
[
|
|
9836
|
+
[symbol2](that) {
|
|
9744
9837
|
return exitIsExit(that) && that._op === "Failure" && // @ts-expect-error
|
|
9745
9838
|
equals(this.effect_instruction_i0, that.effect_instruction_i0);
|
|
9746
9839
|
}
|
|
@@ -9776,19 +9869,18 @@ var EffectPrimitiveFailure = class {
|
|
|
9776
9869
|
return new SingleShotGen2(new YieldWrap(this));
|
|
9777
9870
|
}
|
|
9778
9871
|
};
|
|
9779
|
-
var _a10;
|
|
9780
9872
|
var EffectPrimitiveSuccess = class {
|
|
9873
|
+
_op;
|
|
9874
|
+
effect_instruction_i0 = void 0;
|
|
9875
|
+
effect_instruction_i1 = void 0;
|
|
9876
|
+
effect_instruction_i2 = void 0;
|
|
9877
|
+
trace = void 0;
|
|
9878
|
+
[EffectTypeId2] = effectVariance;
|
|
9781
9879
|
constructor(_op) {
|
|
9782
|
-
__publicField(this, "_op");
|
|
9783
|
-
__publicField(this, "effect_instruction_i0");
|
|
9784
|
-
__publicField(this, "effect_instruction_i1");
|
|
9785
|
-
__publicField(this, "effect_instruction_i2");
|
|
9786
|
-
__publicField(this, "trace");
|
|
9787
|
-
__publicField(this, _a10, effectVariance);
|
|
9788
9880
|
this._op = _op;
|
|
9789
9881
|
this._tag = _op;
|
|
9790
9882
|
}
|
|
9791
|
-
[
|
|
9883
|
+
[symbol2](that) {
|
|
9792
9884
|
return exitIsExit(that) && that._op === "Success" && // @ts-expect-error
|
|
9793
9885
|
equals(this.effect_instruction_i0, that.effect_instruction_i0);
|
|
9794
9886
|
}
|
|
@@ -10228,16 +10320,15 @@ var requestResolverVariance = {
|
|
|
10228
10320
|
/* c8 ignore next */
|
|
10229
10321
|
_R: (_) => _
|
|
10230
10322
|
};
|
|
10231
|
-
var _a11;
|
|
10232
10323
|
var RequestResolverImpl = class _RequestResolverImpl {
|
|
10324
|
+
runAll;
|
|
10325
|
+
target;
|
|
10326
|
+
[RequestResolverTypeId] = requestResolverVariance;
|
|
10233
10327
|
constructor(runAll, target) {
|
|
10234
|
-
__publicField(this, "runAll");
|
|
10235
|
-
__publicField(this, "target");
|
|
10236
|
-
__publicField(this, _a11, requestResolverVariance);
|
|
10237
10328
|
this.runAll = runAll;
|
|
10238
10329
|
this.target = target;
|
|
10239
10330
|
}
|
|
10240
|
-
[
|
|
10331
|
+
[symbol]() {
|
|
10241
10332
|
return cached(this, this.target ? hash(this.target) : random(this));
|
|
10242
10333
|
}
|
|
10243
10334
|
[symbol2](that) {
|
|
@@ -10352,10 +10443,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
|
|
|
10352
10443
|
}();
|
|
10353
10444
|
var makeException = (proto5, tag2) => {
|
|
10354
10445
|
class Base3 extends YieldableError {
|
|
10355
|
-
|
|
10356
|
-
super(...arguments);
|
|
10357
|
-
__publicField(this, "_tag", tag2);
|
|
10358
|
-
}
|
|
10446
|
+
_tag = tag2;
|
|
10359
10447
|
}
|
|
10360
10448
|
Object.assign(Base3.prototype, proto5);
|
|
10361
10449
|
Base3.prototype.name = tag2;
|
|
@@ -10393,12 +10481,12 @@ var TimeoutException = /* @__PURE__ */ makeException({
|
|
|
10393
10481
|
var UnknownExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/UnknownException");
|
|
10394
10482
|
var UnknownException = /* @__PURE__ */ function() {
|
|
10395
10483
|
class UnknownException2 extends YieldableError {
|
|
10484
|
+
_tag = "UnknownException";
|
|
10485
|
+
error;
|
|
10396
10486
|
constructor(cause, message) {
|
|
10397
10487
|
super(message ?? "An unknown error occurred", {
|
|
10398
10488
|
cause
|
|
10399
10489
|
});
|
|
10400
|
-
__publicField(this, "_tag", "UnknownException");
|
|
10401
|
-
__publicField(this, "error");
|
|
10402
10490
|
this.error = cause;
|
|
10403
10491
|
}
|
|
10404
10492
|
}
|
|
@@ -10572,10 +10660,10 @@ var MutableHashMapProto = {
|
|
|
10572
10660
|
}
|
|
10573
10661
|
};
|
|
10574
10662
|
var MutableHashMapIterator = class _MutableHashMapIterator {
|
|
10663
|
+
self;
|
|
10664
|
+
referentialIterator;
|
|
10665
|
+
bucketIterator;
|
|
10575
10666
|
constructor(self) {
|
|
10576
|
-
__publicField(this, "self");
|
|
10577
|
-
__publicField(this, "referentialIterator");
|
|
10578
|
-
__publicField(this, "bucketIterator");
|
|
10579
10667
|
this.self = self;
|
|
10580
10668
|
this.referentialIterator = self.referential[Symbol.iterator]();
|
|
10581
10669
|
}
|
|
@@ -10595,11 +10683,11 @@ var MutableHashMapIterator = class _MutableHashMapIterator {
|
|
|
10595
10683
|
}
|
|
10596
10684
|
};
|
|
10597
10685
|
var BucketIterator = class {
|
|
10686
|
+
backing;
|
|
10598
10687
|
constructor(backing) {
|
|
10599
|
-
__publicField(this, "backing");
|
|
10600
|
-
__publicField(this, "currentBucket");
|
|
10601
10688
|
this.backing = backing;
|
|
10602
10689
|
}
|
|
10690
|
+
currentBucket;
|
|
10603
10691
|
next() {
|
|
10604
10692
|
if (this.currentBucket === void 0) {
|
|
10605
10693
|
const result2 = this.backing.next();
|
|
@@ -10715,20 +10803,16 @@ var processOrPerformanceNow = /* @__PURE__ */ function() {
|
|
|
10715
10803
|
const origin = /* @__PURE__ */ performanceNowNanos() - /* @__PURE__ */ processHrtime.bigint();
|
|
10716
10804
|
return () => origin + processHrtime.bigint();
|
|
10717
10805
|
}();
|
|
10718
|
-
var _a12;
|
|
10719
|
-
_a12 = ClockTypeId;
|
|
10720
10806
|
var ClockImpl = class {
|
|
10721
|
-
|
|
10722
|
-
__publicField(this, _a12, ClockTypeId);
|
|
10723
|
-
__publicField(this, "currentTimeMillis", /* @__PURE__ */ sync(() => this.unsafeCurrentTimeMillis()));
|
|
10724
|
-
__publicField(this, "currentTimeNanos", /* @__PURE__ */ sync(() => this.unsafeCurrentTimeNanos()));
|
|
10725
|
-
}
|
|
10807
|
+
[ClockTypeId] = ClockTypeId;
|
|
10726
10808
|
unsafeCurrentTimeMillis() {
|
|
10727
10809
|
return Date.now();
|
|
10728
10810
|
}
|
|
10729
10811
|
unsafeCurrentTimeNanos() {
|
|
10730
10812
|
return processOrPerformanceNow();
|
|
10731
10813
|
}
|
|
10814
|
+
currentTimeMillis = /* @__PURE__ */ sync(() => this.unsafeCurrentTimeMillis());
|
|
10815
|
+
currentTimeNanos = /* @__PURE__ */ sync(() => this.unsafeCurrentTimeNanos());
|
|
10732
10816
|
scheduler() {
|
|
10733
10817
|
return succeed(globalClockScheduler);
|
|
10734
10818
|
}
|
|
@@ -11222,13 +11306,11 @@ var defaultConsole = {
|
|
|
11222
11306
|
var RandomSymbolKey = "effect/Random";
|
|
11223
11307
|
var RandomTypeId = /* @__PURE__ */ Symbol.for(RandomSymbolKey);
|
|
11224
11308
|
var randomTag = /* @__PURE__ */ GenericTag("effect/Random");
|
|
11225
|
-
var _a13;
|
|
11226
|
-
_a13 = RandomTypeId;
|
|
11227
11309
|
var RandomImpl = class {
|
|
11310
|
+
seed;
|
|
11311
|
+
[RandomTypeId] = RandomTypeId;
|
|
11312
|
+
PRNG;
|
|
11228
11313
|
constructor(seed) {
|
|
11229
|
-
__publicField(this, "seed");
|
|
11230
|
-
__publicField(this, _a13, RandomTypeId);
|
|
11231
|
-
__publicField(this, "PRNG");
|
|
11232
11314
|
this.seed = seed;
|
|
11233
11315
|
this.PRNG = new PCGRandom(seed);
|
|
11234
11316
|
}
|
|
@@ -11288,20 +11370,20 @@ var randomHexString = /* @__PURE__ */ function() {
|
|
|
11288
11370
|
};
|
|
11289
11371
|
}();
|
|
11290
11372
|
var NativeSpan = class {
|
|
11373
|
+
name;
|
|
11374
|
+
parent;
|
|
11375
|
+
context;
|
|
11376
|
+
links;
|
|
11377
|
+
startTime;
|
|
11378
|
+
kind;
|
|
11379
|
+
_tag = "Span";
|
|
11380
|
+
spanId;
|
|
11381
|
+
traceId = "native";
|
|
11382
|
+
sampled = true;
|
|
11383
|
+
status;
|
|
11384
|
+
attributes;
|
|
11385
|
+
events = [];
|
|
11291
11386
|
constructor(name, parent, context3, links, startTime, kind) {
|
|
11292
|
-
__publicField(this, "name");
|
|
11293
|
-
__publicField(this, "parent");
|
|
11294
|
-
__publicField(this, "context");
|
|
11295
|
-
__publicField(this, "links");
|
|
11296
|
-
__publicField(this, "startTime");
|
|
11297
|
-
__publicField(this, "kind");
|
|
11298
|
-
__publicField(this, "_tag", "Span");
|
|
11299
|
-
__publicField(this, "spanId");
|
|
11300
|
-
__publicField(this, "traceId", "native");
|
|
11301
|
-
__publicField(this, "sampled", true);
|
|
11302
|
-
__publicField(this, "status");
|
|
11303
|
-
__publicField(this, "attributes");
|
|
11304
|
-
__publicField(this, "events", []);
|
|
11305
11387
|
this.name = name;
|
|
11306
11388
|
this.parent = parent;
|
|
11307
11389
|
this.context = context3;
|
|
@@ -11351,12 +11433,10 @@ function empty17() {
|
|
|
11351
11433
|
return unsafeMake3(/* @__PURE__ */ new Map());
|
|
11352
11434
|
}
|
|
11353
11435
|
var FiberRefsSym = /* @__PURE__ */ Symbol.for("effect/FiberRefs");
|
|
11354
|
-
var _a14;
|
|
11355
|
-
_a14 = FiberRefsSym;
|
|
11356
11436
|
var FiberRefsImpl = class {
|
|
11437
|
+
locals;
|
|
11438
|
+
[FiberRefsSym] = FiberRefsSym;
|
|
11357
11439
|
constructor(locals) {
|
|
11358
|
-
__publicField(this, "locals");
|
|
11359
|
-
__publicField(this, _a14, FiberRefsSym);
|
|
11360
11440
|
this.locals = locals;
|
|
11361
11441
|
}
|
|
11362
11442
|
pipe() {
|
|
@@ -11655,18 +11735,17 @@ var patch6 = /* @__PURE__ */ dual(3, (self, fiberId2, oldValue) => {
|
|
|
11655
11735
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/internal/metric/label.js
|
|
11656
11736
|
var MetricLabelSymbolKey = "effect/MetricLabel";
|
|
11657
11737
|
var MetricLabelTypeId = /* @__PURE__ */ Symbol.for(MetricLabelSymbolKey);
|
|
11658
|
-
var _a15;
|
|
11659
11738
|
var MetricLabelImpl = class {
|
|
11739
|
+
key;
|
|
11740
|
+
value;
|
|
11741
|
+
[MetricLabelTypeId] = MetricLabelTypeId;
|
|
11742
|
+
_hash;
|
|
11660
11743
|
constructor(key, value3) {
|
|
11661
|
-
__publicField(this, "key");
|
|
11662
|
-
__publicField(this, "value");
|
|
11663
|
-
__publicField(this, _a15, MetricLabelTypeId);
|
|
11664
|
-
__publicField(this, "_hash");
|
|
11665
11744
|
this.key = key;
|
|
11666
11745
|
this.value = value3;
|
|
11667
11746
|
this._hash = string(MetricLabelSymbolKey + this.key + this.value);
|
|
11668
11747
|
}
|
|
11669
|
-
[
|
|
11748
|
+
[symbol]() {
|
|
11670
11749
|
return this._hash;
|
|
11671
11750
|
}
|
|
11672
11751
|
[symbol2](that) {
|
|
@@ -11714,45 +11793,40 @@ var OP_DONE = "Done";
|
|
|
11714
11793
|
var OP_RUNNING = "Running";
|
|
11715
11794
|
var OP_SUSPENDED = "Suspended";
|
|
11716
11795
|
var DoneHash = /* @__PURE__ */ string(`${FiberStatusSymbolKey}-${OP_DONE}`);
|
|
11717
|
-
var _a16;
|
|
11718
11796
|
var Done = class {
|
|
11719
|
-
|
|
11720
|
-
|
|
11721
|
-
|
|
11722
|
-
}
|
|
11723
|
-
[(_a16 = FiberStatusTypeId, symbol)]() {
|
|
11797
|
+
[FiberStatusTypeId] = FiberStatusTypeId;
|
|
11798
|
+
_tag = OP_DONE;
|
|
11799
|
+
[symbol]() {
|
|
11724
11800
|
return DoneHash;
|
|
11725
11801
|
}
|
|
11726
11802
|
[symbol2](that) {
|
|
11727
11803
|
return isFiberStatus(that) && that._tag === OP_DONE;
|
|
11728
11804
|
}
|
|
11729
11805
|
};
|
|
11730
|
-
var _a17;
|
|
11731
11806
|
var Running = class {
|
|
11807
|
+
runtimeFlags;
|
|
11808
|
+
[FiberStatusTypeId] = FiberStatusTypeId;
|
|
11809
|
+
_tag = OP_RUNNING;
|
|
11732
11810
|
constructor(runtimeFlags2) {
|
|
11733
|
-
__publicField(this, "runtimeFlags");
|
|
11734
|
-
__publicField(this, _a17, FiberStatusTypeId);
|
|
11735
|
-
__publicField(this, "_tag", OP_RUNNING);
|
|
11736
11811
|
this.runtimeFlags = runtimeFlags2;
|
|
11737
11812
|
}
|
|
11738
|
-
[
|
|
11813
|
+
[symbol]() {
|
|
11739
11814
|
return pipe(hash(FiberStatusSymbolKey), combine(hash(this._tag)), combine(hash(this.runtimeFlags)), cached(this));
|
|
11740
11815
|
}
|
|
11741
11816
|
[symbol2](that) {
|
|
11742
11817
|
return isFiberStatus(that) && that._tag === OP_RUNNING && this.runtimeFlags === that.runtimeFlags;
|
|
11743
11818
|
}
|
|
11744
11819
|
};
|
|
11745
|
-
var _a18;
|
|
11746
11820
|
var Suspended = class {
|
|
11821
|
+
runtimeFlags;
|
|
11822
|
+
blockingOn;
|
|
11823
|
+
[FiberStatusTypeId] = FiberStatusTypeId;
|
|
11824
|
+
_tag = OP_SUSPENDED;
|
|
11747
11825
|
constructor(runtimeFlags2, blockingOn) {
|
|
11748
|
-
__publicField(this, "runtimeFlags");
|
|
11749
|
-
__publicField(this, "blockingOn");
|
|
11750
|
-
__publicField(this, _a18, FiberStatusTypeId);
|
|
11751
|
-
__publicField(this, "_tag", OP_SUSPENDED);
|
|
11752
11826
|
this.runtimeFlags = runtimeFlags2;
|
|
11753
11827
|
this.blockingOn = blockingOn;
|
|
11754
11828
|
}
|
|
11755
|
-
[
|
|
11829
|
+
[symbol]() {
|
|
11756
11830
|
return pipe(hash(FiberStatusSymbolKey), combine(hash(this._tag)), combine(hash(this.runtimeFlags)), combine(hash(this.blockingOn)), cached(this));
|
|
11757
11831
|
}
|
|
11758
11832
|
[symbol2](that) {
|
|
@@ -11778,8 +11852,10 @@ var MicroCauseTypeId = /* @__PURE__ */ Symbol.for("effect/Micro/MicroCause");
|
|
|
11778
11852
|
var microCauseVariance = {
|
|
11779
11853
|
_E: identity
|
|
11780
11854
|
};
|
|
11781
|
-
var _a19;
|
|
11782
11855
|
var MicroCauseImpl = class extends globalThis.Error {
|
|
11856
|
+
_tag;
|
|
11857
|
+
traces;
|
|
11858
|
+
[MicroCauseTypeId];
|
|
11783
11859
|
constructor(_tag, originalError, traces) {
|
|
11784
11860
|
const causeName = `MicroCause.${_tag}`;
|
|
11785
11861
|
let name;
|
|
@@ -11800,9 +11876,6 @@ var MicroCauseImpl = class extends globalThis.Error {
|
|
|
11800
11876
|
${traces.join("\n ")}`;
|
|
11801
11877
|
}
|
|
11802
11878
|
super(message);
|
|
11803
|
-
__publicField(this, "_tag");
|
|
11804
|
-
__publicField(this, "traces");
|
|
11805
|
-
__publicField(this, _a19);
|
|
11806
11879
|
this._tag = _tag;
|
|
11807
11880
|
this.traces = traces;
|
|
11808
11881
|
this[MicroCauseTypeId] = microCauseVariance;
|
|
@@ -11815,14 +11888,14 @@ var MicroCauseImpl = class extends globalThis.Error {
|
|
|
11815
11888
|
toString() {
|
|
11816
11889
|
return this.stack;
|
|
11817
11890
|
}
|
|
11818
|
-
[
|
|
11891
|
+
[NodeInspectSymbol]() {
|
|
11819
11892
|
return this.stack;
|
|
11820
11893
|
}
|
|
11821
11894
|
};
|
|
11822
11895
|
var Die = class extends MicroCauseImpl {
|
|
11896
|
+
defect;
|
|
11823
11897
|
constructor(defect, traces = []) {
|
|
11824
11898
|
super("Die", defect, traces);
|
|
11825
|
-
__publicField(this, "defect");
|
|
11826
11899
|
this.defect = defect;
|
|
11827
11900
|
}
|
|
11828
11901
|
};
|
|
@@ -11839,21 +11912,16 @@ var fiberVariance = {
|
|
|
11839
11912
|
_A: identity,
|
|
11840
11913
|
_E: identity
|
|
11841
11914
|
};
|
|
11842
|
-
var _a20;
|
|
11843
|
-
_a20 = MicroFiberTypeId;
|
|
11844
11915
|
var MicroFiberImpl = class {
|
|
11916
|
+
context;
|
|
11917
|
+
interruptible;
|
|
11918
|
+
[MicroFiberTypeId];
|
|
11919
|
+
_stack = [];
|
|
11920
|
+
_observers = [];
|
|
11921
|
+
_exit;
|
|
11922
|
+
_children;
|
|
11923
|
+
currentOpCount = 0;
|
|
11845
11924
|
constructor(context3, interruptible4 = true) {
|
|
11846
|
-
__publicField(this, "context");
|
|
11847
|
-
__publicField(this, "interruptible");
|
|
11848
|
-
__publicField(this, _a20);
|
|
11849
|
-
__publicField(this, "_stack", []);
|
|
11850
|
-
__publicField(this, "_observers", []);
|
|
11851
|
-
__publicField(this, "_exit");
|
|
11852
|
-
__publicField(this, "_children");
|
|
11853
|
-
__publicField(this, "currentOpCount", 0);
|
|
11854
|
-
__publicField(this, "_interrupted", false);
|
|
11855
|
-
// cancel the yielded operation, or for the yielded exit value
|
|
11856
|
-
__publicField(this, "_yielded");
|
|
11857
11925
|
this.context = context3;
|
|
11858
11926
|
this.interruptible = interruptible4;
|
|
11859
11927
|
this[MicroFiberTypeId] = fiberVariance;
|
|
@@ -11874,6 +11942,7 @@ var MicroFiberImpl = class {
|
|
|
11874
11942
|
}
|
|
11875
11943
|
};
|
|
11876
11944
|
}
|
|
11945
|
+
_interrupted = false;
|
|
11877
11946
|
unsafeInterrupt() {
|
|
11878
11947
|
if (this._exit) {
|
|
11879
11948
|
return;
|
|
@@ -11948,6 +12017,8 @@ var MicroFiberImpl = class {
|
|
|
11948
12017
|
if (op[symbol3]) return op;
|
|
11949
12018
|
}
|
|
11950
12019
|
}
|
|
12020
|
+
// cancel the yielded operation, or for the yielded exit value
|
|
12021
|
+
_yielded = void 0;
|
|
11951
12022
|
yieldWith(value3) {
|
|
11952
12023
|
this._yielded = value3;
|
|
11953
12024
|
return Yield;
|
|
@@ -12203,17 +12274,8 @@ var exitVoidAll = (exits) => {
|
|
|
12203
12274
|
};
|
|
12204
12275
|
var setImmediate = "setImmediate" in globalThis ? globalThis.setImmediate : (f) => setTimeout(f, 0);
|
|
12205
12276
|
var MicroSchedulerDefault = class {
|
|
12206
|
-
|
|
12207
|
-
|
|
12208
|
-
__publicField(this, "running", false);
|
|
12209
|
-
/**
|
|
12210
|
-
* @since 3.5.9
|
|
12211
|
-
*/
|
|
12212
|
-
__publicField(this, "afterScheduled", () => {
|
|
12213
|
-
this.running = false;
|
|
12214
|
-
this.runTasks();
|
|
12215
|
-
});
|
|
12216
|
-
}
|
|
12277
|
+
tasks = [];
|
|
12278
|
+
running = false;
|
|
12217
12279
|
/**
|
|
12218
12280
|
* @since 3.5.9
|
|
12219
12281
|
*/
|
|
@@ -12224,6 +12286,13 @@ var MicroSchedulerDefault = class {
|
|
|
12224
12286
|
setImmediate(this.afterScheduled);
|
|
12225
12287
|
}
|
|
12226
12288
|
}
|
|
12289
|
+
/**
|
|
12290
|
+
* @since 3.5.9
|
|
12291
|
+
*/
|
|
12292
|
+
afterScheduled = () => {
|
|
12293
|
+
this.running = false;
|
|
12294
|
+
this.runTasks();
|
|
12295
|
+
};
|
|
12227
12296
|
/**
|
|
12228
12297
|
* @since 3.5.9
|
|
12229
12298
|
*/
|
|
@@ -12289,15 +12358,13 @@ var matchCause2 = /* @__PURE__ */ dual(2, (self, options) => matchCauseEffect2(s
|
|
|
12289
12358
|
onSuccess: (value3) => sync2(() => options.onSuccess(value3))
|
|
12290
12359
|
}));
|
|
12291
12360
|
var MicroScopeTypeId = /* @__PURE__ */ Symbol.for("effect/Micro/MicroScope");
|
|
12292
|
-
var
|
|
12293
|
-
|
|
12294
|
-
|
|
12361
|
+
var MicroScopeImpl = class _MicroScopeImpl {
|
|
12362
|
+
[MicroScopeTypeId];
|
|
12363
|
+
state = {
|
|
12364
|
+
_tag: "Open",
|
|
12365
|
+
finalizers: /* @__PURE__ */ new Set()
|
|
12366
|
+
};
|
|
12295
12367
|
constructor() {
|
|
12296
|
-
__publicField(this, _a21);
|
|
12297
|
-
__publicField(this, "state", {
|
|
12298
|
-
_tag: "Open",
|
|
12299
|
-
finalizers: /* @__PURE__ */ new Set()
|
|
12300
|
-
});
|
|
12301
12368
|
this[MicroScopeTypeId] = MicroScopeTypeId;
|
|
12302
12369
|
}
|
|
12303
12370
|
unsafeAddFinalizer(finalizer) {
|
|
@@ -12348,7 +12415,6 @@ var _MicroScopeImpl = class _MicroScopeImpl {
|
|
|
12348
12415
|
});
|
|
12349
12416
|
}
|
|
12350
12417
|
};
|
|
12351
|
-
var MicroScopeImpl = _MicroScopeImpl;
|
|
12352
12418
|
var onExit2 = /* @__PURE__ */ dual(2, (self, f) => uninterruptibleMask2((restore) => matchCauseEffect2(restore(self), {
|
|
12353
12419
|
onFailure: (cause) => flatMap8(f(exitFailCause2(cause)), () => failCause3(cause)),
|
|
12354
12420
|
onSuccess: (a) => flatMap8(f(exitSucceed2(a)), () => succeed3(a))
|
|
@@ -12448,8 +12514,8 @@ var forEach3 = (iterable, f, options) => withMicroFiber((parent) => {
|
|
|
12448
12514
|
pump();
|
|
12449
12515
|
}
|
|
12450
12516
|
});
|
|
12451
|
-
} catch (
|
|
12452
|
-
result = exitDie2(
|
|
12517
|
+
} catch (err2) {
|
|
12518
|
+
result = exitDie2(err2);
|
|
12453
12519
|
length2 = index;
|
|
12454
12520
|
fibers.forEach((fiber) => fiber.unsafeInterrupt());
|
|
12455
12521
|
}
|
|
@@ -12496,12 +12562,10 @@ var runFork = (effect, options) => {
|
|
|
12496
12562
|
|
|
12497
12563
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/Scheduler.js
|
|
12498
12564
|
var PriorityBuckets = class {
|
|
12499
|
-
|
|
12500
|
-
|
|
12501
|
-
|
|
12502
|
-
|
|
12503
|
-
__publicField(this, "buckets", []);
|
|
12504
|
-
}
|
|
12565
|
+
/**
|
|
12566
|
+
* @since 2.0.0
|
|
12567
|
+
*/
|
|
12568
|
+
buckets = [];
|
|
12505
12569
|
/**
|
|
12506
12570
|
* @since 2.0.0
|
|
12507
12571
|
*/
|
|
@@ -12526,16 +12590,16 @@ var PriorityBuckets = class {
|
|
|
12526
12590
|
}
|
|
12527
12591
|
};
|
|
12528
12592
|
var MixedScheduler = class {
|
|
12593
|
+
maxNextTickBeforeTimer;
|
|
12594
|
+
/**
|
|
12595
|
+
* @since 2.0.0
|
|
12596
|
+
*/
|
|
12597
|
+
running = false;
|
|
12598
|
+
/**
|
|
12599
|
+
* @since 2.0.0
|
|
12600
|
+
*/
|
|
12601
|
+
tasks = /* @__PURE__ */ new PriorityBuckets();
|
|
12529
12602
|
constructor(maxNextTickBeforeTimer) {
|
|
12530
|
-
__publicField(this, "maxNextTickBeforeTimer");
|
|
12531
|
-
/**
|
|
12532
|
-
* @since 2.0.0
|
|
12533
|
-
*/
|
|
12534
|
-
__publicField(this, "running", false);
|
|
12535
|
-
/**
|
|
12536
|
-
* @since 2.0.0
|
|
12537
|
-
*/
|
|
12538
|
-
__publicField(this, "tasks", /* @__PURE__ */ new PriorityBuckets());
|
|
12539
12603
|
this.maxNextTickBeforeTimer = maxNextTickBeforeTimer;
|
|
12540
12604
|
}
|
|
12541
12605
|
/**
|
|
@@ -12584,16 +12648,14 @@ var MixedScheduler = class {
|
|
|
12584
12648
|
};
|
|
12585
12649
|
var defaultScheduler = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Scheduler/defaultScheduler"), () => new MixedScheduler(2048));
|
|
12586
12650
|
var SyncScheduler = class {
|
|
12587
|
-
|
|
12588
|
-
|
|
12589
|
-
|
|
12590
|
-
|
|
12591
|
-
|
|
12592
|
-
|
|
12593
|
-
|
|
12594
|
-
|
|
12595
|
-
__publicField(this, "deferred", false);
|
|
12596
|
-
}
|
|
12651
|
+
/**
|
|
12652
|
+
* @since 2.0.0
|
|
12653
|
+
*/
|
|
12654
|
+
tasks = /* @__PURE__ */ new PriorityBuckets();
|
|
12655
|
+
/**
|
|
12656
|
+
* @since 2.0.0
|
|
12657
|
+
*/
|
|
12658
|
+
deferred = false;
|
|
12597
12659
|
/**
|
|
12598
12660
|
* @since 2.0.0
|
|
12599
12661
|
*/
|
|
@@ -12669,14 +12731,10 @@ var yieldNow3 = () => ({
|
|
|
12669
12731
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/internal/fiberScope.js
|
|
12670
12732
|
var FiberScopeSymbolKey = "effect/FiberScope";
|
|
12671
12733
|
var FiberScopeTypeId = /* @__PURE__ */ Symbol.for(FiberScopeSymbolKey);
|
|
12672
|
-
var _a22;
|
|
12673
|
-
_a22 = FiberScopeTypeId;
|
|
12674
12734
|
var Global = class {
|
|
12675
|
-
|
|
12676
|
-
|
|
12677
|
-
|
|
12678
|
-
__publicField(this, "roots", /* @__PURE__ */ new Set());
|
|
12679
|
-
}
|
|
12735
|
+
[FiberScopeTypeId] = FiberScopeTypeId;
|
|
12736
|
+
fiberId = none4;
|
|
12737
|
+
roots = /* @__PURE__ */ new Set();
|
|
12680
12738
|
add(_runtimeFlags, child) {
|
|
12681
12739
|
this.roots.add(child);
|
|
12682
12740
|
child.addObserver(() => {
|
|
@@ -12684,13 +12742,11 @@ var Global = class {
|
|
|
12684
12742
|
});
|
|
12685
12743
|
}
|
|
12686
12744
|
};
|
|
12687
|
-
var _a23;
|
|
12688
|
-
_a23 = FiberScopeTypeId;
|
|
12689
12745
|
var Local = class {
|
|
12746
|
+
fiberId;
|
|
12747
|
+
parent;
|
|
12748
|
+
[FiberScopeTypeId] = FiberScopeTypeId;
|
|
12690
12749
|
constructor(fiberId2, parent) {
|
|
12691
|
-
__publicField(this, "fiberId");
|
|
12692
|
-
__publicField(this, "parent");
|
|
12693
|
-
__publicField(this, _a23, FiberScopeTypeId);
|
|
12694
12750
|
this.fiberId = fiberId2;
|
|
12695
12751
|
this.parent = parent;
|
|
12696
12752
|
}
|
|
@@ -12828,16 +12884,15 @@ var hasProcessStdoutOrDeno = hasProcessStdout || "Deno" in globalThis;
|
|
|
12828
12884
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/internal/metric/boundaries.js
|
|
12829
12885
|
var MetricBoundariesSymbolKey = "effect/MetricBoundaries";
|
|
12830
12886
|
var MetricBoundariesTypeId = /* @__PURE__ */ Symbol.for(MetricBoundariesSymbolKey);
|
|
12831
|
-
var _a24;
|
|
12832
12887
|
var MetricBoundariesImpl = class {
|
|
12888
|
+
values;
|
|
12889
|
+
[MetricBoundariesTypeId] = MetricBoundariesTypeId;
|
|
12833
12890
|
constructor(values4) {
|
|
12834
|
-
__publicField(this, "values");
|
|
12835
|
-
__publicField(this, _a24, MetricBoundariesTypeId);
|
|
12836
|
-
__publicField(this, "_hash");
|
|
12837
12891
|
this.values = values4;
|
|
12838
12892
|
this._hash = pipe(string(MetricBoundariesSymbolKey), combine(array2(this.values)));
|
|
12839
12893
|
}
|
|
12840
|
-
|
|
12894
|
+
_hash;
|
|
12895
|
+
[symbol]() {
|
|
12841
12896
|
return this._hash;
|
|
12842
12897
|
}
|
|
12843
12898
|
[symbol2](u) {
|
|
@@ -12873,19 +12928,18 @@ var metricKeyTypeVariance = {
|
|
|
12873
12928
|
/* c8 ignore next */
|
|
12874
12929
|
_Out: (_) => _
|
|
12875
12930
|
};
|
|
12876
|
-
var _a25, _b;
|
|
12877
12931
|
var CounterKeyType = class {
|
|
12932
|
+
incremental;
|
|
12933
|
+
bigint;
|
|
12934
|
+
[MetricKeyTypeTypeId] = metricKeyTypeVariance;
|
|
12935
|
+
[CounterKeyTypeTypeId] = CounterKeyTypeTypeId;
|
|
12878
12936
|
constructor(incremental, bigint2) {
|
|
12879
|
-
__publicField(this, "incremental");
|
|
12880
|
-
__publicField(this, "bigint");
|
|
12881
|
-
__publicField(this, _b, metricKeyTypeVariance);
|
|
12882
|
-
__publicField(this, _a25, CounterKeyTypeTypeId);
|
|
12883
|
-
__publicField(this, "_hash");
|
|
12884
12937
|
this.incremental = incremental;
|
|
12885
12938
|
this.bigint = bigint2;
|
|
12886
12939
|
this._hash = string(CounterKeyTypeSymbolKey);
|
|
12887
12940
|
}
|
|
12888
|
-
|
|
12941
|
+
_hash;
|
|
12942
|
+
[symbol]() {
|
|
12889
12943
|
return this._hash;
|
|
12890
12944
|
}
|
|
12891
12945
|
[symbol2](that) {
|
|
@@ -12896,15 +12950,14 @@ var CounterKeyType = class {
|
|
|
12896
12950
|
}
|
|
12897
12951
|
};
|
|
12898
12952
|
var FrequencyKeyTypeHash = /* @__PURE__ */ string(FrequencyKeyTypeSymbolKey);
|
|
12899
|
-
var _a26, _b2;
|
|
12900
12953
|
var FrequencyKeyType = class {
|
|
12954
|
+
preregisteredWords;
|
|
12955
|
+
[MetricKeyTypeTypeId] = metricKeyTypeVariance;
|
|
12956
|
+
[FrequencyKeyTypeTypeId] = FrequencyKeyTypeTypeId;
|
|
12901
12957
|
constructor(preregisteredWords) {
|
|
12902
|
-
__publicField(this, "preregisteredWords");
|
|
12903
|
-
__publicField(this, _b2, metricKeyTypeVariance);
|
|
12904
|
-
__publicField(this, _a26, FrequencyKeyTypeTypeId);
|
|
12905
12958
|
this.preregisteredWords = preregisteredWords;
|
|
12906
12959
|
}
|
|
12907
|
-
[
|
|
12960
|
+
[symbol]() {
|
|
12908
12961
|
return FrequencyKeyTypeHash;
|
|
12909
12962
|
}
|
|
12910
12963
|
[symbol2](that) {
|
|
@@ -12915,15 +12968,14 @@ var FrequencyKeyType = class {
|
|
|
12915
12968
|
}
|
|
12916
12969
|
};
|
|
12917
12970
|
var GaugeKeyTypeHash = /* @__PURE__ */ string(GaugeKeyTypeSymbolKey);
|
|
12918
|
-
var _a27, _b3;
|
|
12919
12971
|
var GaugeKeyType = class {
|
|
12972
|
+
bigint;
|
|
12973
|
+
[MetricKeyTypeTypeId] = metricKeyTypeVariance;
|
|
12974
|
+
[GaugeKeyTypeTypeId] = GaugeKeyTypeTypeId;
|
|
12920
12975
|
constructor(bigint2) {
|
|
12921
|
-
__publicField(this, "bigint");
|
|
12922
|
-
__publicField(this, _b3, metricKeyTypeVariance);
|
|
12923
|
-
__publicField(this, _a27, GaugeKeyTypeTypeId);
|
|
12924
12976
|
this.bigint = bigint2;
|
|
12925
12977
|
}
|
|
12926
|
-
[
|
|
12978
|
+
[symbol]() {
|
|
12927
12979
|
return GaugeKeyTypeHash;
|
|
12928
12980
|
}
|
|
12929
12981
|
[symbol2](that) {
|
|
@@ -12933,17 +12985,16 @@ var GaugeKeyType = class {
|
|
|
12933
12985
|
return pipeArguments(this, arguments);
|
|
12934
12986
|
}
|
|
12935
12987
|
};
|
|
12936
|
-
var _a28, _b4;
|
|
12937
12988
|
var HistogramKeyType = class {
|
|
12989
|
+
boundaries;
|
|
12990
|
+
[MetricKeyTypeTypeId] = metricKeyTypeVariance;
|
|
12991
|
+
[HistogramKeyTypeTypeId] = HistogramKeyTypeTypeId;
|
|
12938
12992
|
constructor(boundaries) {
|
|
12939
|
-
__publicField(this, "boundaries");
|
|
12940
|
-
__publicField(this, _b4, metricKeyTypeVariance);
|
|
12941
|
-
__publicField(this, _a28, HistogramKeyTypeTypeId);
|
|
12942
|
-
__publicField(this, "_hash");
|
|
12943
12993
|
this.boundaries = boundaries;
|
|
12944
12994
|
this._hash = pipe(string(HistogramKeyTypeSymbolKey), combine(hash(this.boundaries)));
|
|
12945
12995
|
}
|
|
12946
|
-
|
|
12996
|
+
_hash;
|
|
12997
|
+
[symbol]() {
|
|
12947
12998
|
return this._hash;
|
|
12948
12999
|
}
|
|
12949
13000
|
[symbol2](that) {
|
|
@@ -12953,23 +13004,22 @@ var HistogramKeyType = class {
|
|
|
12953
13004
|
return pipeArguments(this, arguments);
|
|
12954
13005
|
}
|
|
12955
13006
|
};
|
|
12956
|
-
var _a29, _b5;
|
|
12957
13007
|
var SummaryKeyType = class {
|
|
13008
|
+
maxAge;
|
|
13009
|
+
maxSize;
|
|
13010
|
+
error;
|
|
13011
|
+
quantiles;
|
|
13012
|
+
[MetricKeyTypeTypeId] = metricKeyTypeVariance;
|
|
13013
|
+
[SummaryKeyTypeTypeId] = SummaryKeyTypeTypeId;
|
|
12958
13014
|
constructor(maxAge, maxSize, error, quantiles) {
|
|
12959
|
-
__publicField(this, "maxAge");
|
|
12960
|
-
__publicField(this, "maxSize");
|
|
12961
|
-
__publicField(this, "error");
|
|
12962
|
-
__publicField(this, "quantiles");
|
|
12963
|
-
__publicField(this, _b5, metricKeyTypeVariance);
|
|
12964
|
-
__publicField(this, _a29, SummaryKeyTypeTypeId);
|
|
12965
|
-
__publicField(this, "_hash");
|
|
12966
13015
|
this.maxAge = maxAge;
|
|
12967
13016
|
this.maxSize = maxSize;
|
|
12968
13017
|
this.error = error;
|
|
12969
13018
|
this.quantiles = quantiles;
|
|
12970
13019
|
this._hash = pipe(string(SummaryKeyTypeSymbolKey), combine(hash(this.maxAge)), combine(hash(this.maxSize)), combine(hash(this.error)), combine(array2(this.quantiles)));
|
|
12971
13020
|
}
|
|
12972
|
-
|
|
13021
|
+
_hash;
|
|
13022
|
+
[symbol]() {
|
|
12973
13023
|
return this._hash;
|
|
12974
13024
|
}
|
|
12975
13025
|
[symbol2](that) {
|
|
@@ -12997,22 +13047,21 @@ var metricKeyVariance = {
|
|
|
12997
13047
|
_Type: (_) => _
|
|
12998
13048
|
};
|
|
12999
13049
|
var arrayEquivilence = /* @__PURE__ */ getEquivalence3(equals);
|
|
13000
|
-
var _a30;
|
|
13001
13050
|
var MetricKeyImpl = class {
|
|
13051
|
+
name;
|
|
13052
|
+
keyType;
|
|
13053
|
+
description;
|
|
13054
|
+
tags;
|
|
13055
|
+
[MetricKeyTypeId] = metricKeyVariance;
|
|
13002
13056
|
constructor(name, keyType, description, tags = []) {
|
|
13003
|
-
__publicField(this, "name");
|
|
13004
|
-
__publicField(this, "keyType");
|
|
13005
|
-
__publicField(this, "description");
|
|
13006
|
-
__publicField(this, "tags");
|
|
13007
|
-
__publicField(this, _a30, metricKeyVariance);
|
|
13008
|
-
__publicField(this, "_hash");
|
|
13009
13057
|
this.name = name;
|
|
13010
13058
|
this.keyType = keyType;
|
|
13011
13059
|
this.description = description;
|
|
13012
13060
|
this.tags = tags;
|
|
13013
13061
|
this._hash = pipe(string(this.name + this.description), combine(hash(this.keyType)), combine(array2(this.tags)));
|
|
13014
13062
|
}
|
|
13015
|
-
|
|
13063
|
+
_hash;
|
|
13064
|
+
[symbol]() {
|
|
13016
13065
|
return this._hash;
|
|
13017
13066
|
}
|
|
13018
13067
|
[symbol2](u) {
|
|
@@ -13044,15 +13093,14 @@ var metricStateVariance = {
|
|
|
13044
13093
|
/* c8 ignore next */
|
|
13045
13094
|
_A: (_) => _
|
|
13046
13095
|
};
|
|
13047
|
-
var _a31, _b6;
|
|
13048
13096
|
var CounterState = class {
|
|
13097
|
+
count;
|
|
13098
|
+
[MetricStateTypeId] = metricStateVariance;
|
|
13099
|
+
[CounterStateTypeId] = CounterStateTypeId;
|
|
13049
13100
|
constructor(count) {
|
|
13050
|
-
__publicField(this, "count");
|
|
13051
|
-
__publicField(this, _b6, metricStateVariance);
|
|
13052
|
-
__publicField(this, _a31, CounterStateTypeId);
|
|
13053
13101
|
this.count = count;
|
|
13054
13102
|
}
|
|
13055
|
-
[
|
|
13103
|
+
[symbol]() {
|
|
13056
13104
|
return pipe(hash(CounterStateSymbolKey), combine(hash(this.count)), cached(this));
|
|
13057
13105
|
}
|
|
13058
13106
|
[symbol2](that) {
|
|
@@ -13063,16 +13111,15 @@ var CounterState = class {
|
|
|
13063
13111
|
}
|
|
13064
13112
|
};
|
|
13065
13113
|
var arrayEquals = /* @__PURE__ */ getEquivalence3(equals);
|
|
13066
|
-
var _a32, _b7;
|
|
13067
13114
|
var FrequencyState = class {
|
|
13115
|
+
occurrences;
|
|
13116
|
+
[MetricStateTypeId] = metricStateVariance;
|
|
13117
|
+
[FrequencyStateTypeId] = FrequencyStateTypeId;
|
|
13068
13118
|
constructor(occurrences) {
|
|
13069
|
-
__publicField(this, "occurrences");
|
|
13070
|
-
__publicField(this, _b7, metricStateVariance);
|
|
13071
|
-
__publicField(this, _a32, FrequencyStateTypeId);
|
|
13072
|
-
__publicField(this, "_hash");
|
|
13073
13119
|
this.occurrences = occurrences;
|
|
13074
13120
|
}
|
|
13075
|
-
|
|
13121
|
+
_hash;
|
|
13122
|
+
[symbol]() {
|
|
13076
13123
|
return pipe(string(FrequencyStateSymbolKey), combine(array2(fromIterable(this.occurrences.entries()))), cached(this));
|
|
13077
13124
|
}
|
|
13078
13125
|
[symbol2](that) {
|
|
@@ -13082,15 +13129,14 @@ var FrequencyState = class {
|
|
|
13082
13129
|
return pipeArguments(this, arguments);
|
|
13083
13130
|
}
|
|
13084
13131
|
};
|
|
13085
|
-
var _a33, _b8;
|
|
13086
13132
|
var GaugeState = class {
|
|
13133
|
+
value;
|
|
13134
|
+
[MetricStateTypeId] = metricStateVariance;
|
|
13135
|
+
[GaugeStateTypeId] = GaugeStateTypeId;
|
|
13087
13136
|
constructor(value3) {
|
|
13088
|
-
__publicField(this, "value");
|
|
13089
|
-
__publicField(this, _b8, metricStateVariance);
|
|
13090
|
-
__publicField(this, _a33, GaugeStateTypeId);
|
|
13091
13137
|
this.value = value3;
|
|
13092
13138
|
}
|
|
13093
|
-
[
|
|
13139
|
+
[symbol]() {
|
|
13094
13140
|
return pipe(hash(GaugeStateSymbolKey), combine(hash(this.value)), cached(this));
|
|
13095
13141
|
}
|
|
13096
13142
|
[symbol2](u) {
|
|
@@ -13100,23 +13146,22 @@ var GaugeState = class {
|
|
|
13100
13146
|
return pipeArguments(this, arguments);
|
|
13101
13147
|
}
|
|
13102
13148
|
};
|
|
13103
|
-
var _a34, _b9;
|
|
13104
13149
|
var HistogramState = class {
|
|
13150
|
+
buckets;
|
|
13151
|
+
count;
|
|
13152
|
+
min;
|
|
13153
|
+
max;
|
|
13154
|
+
sum;
|
|
13155
|
+
[MetricStateTypeId] = metricStateVariance;
|
|
13156
|
+
[HistogramStateTypeId] = HistogramStateTypeId;
|
|
13105
13157
|
constructor(buckets, count, min3, max3, sum) {
|
|
13106
|
-
__publicField(this, "buckets");
|
|
13107
|
-
__publicField(this, "count");
|
|
13108
|
-
__publicField(this, "min");
|
|
13109
|
-
__publicField(this, "max");
|
|
13110
|
-
__publicField(this, "sum");
|
|
13111
|
-
__publicField(this, _b9, metricStateVariance);
|
|
13112
|
-
__publicField(this, _a34, HistogramStateTypeId);
|
|
13113
13158
|
this.buckets = buckets;
|
|
13114
13159
|
this.count = count;
|
|
13115
13160
|
this.min = min3;
|
|
13116
13161
|
this.max = max3;
|
|
13117
13162
|
this.sum = sum;
|
|
13118
13163
|
}
|
|
13119
|
-
[
|
|
13164
|
+
[symbol]() {
|
|
13120
13165
|
return pipe(hash(HistogramStateSymbolKey), combine(hash(this.buckets)), combine(hash(this.count)), combine(hash(this.min)), combine(hash(this.max)), combine(hash(this.sum)), cached(this));
|
|
13121
13166
|
}
|
|
13122
13167
|
[symbol2](that) {
|
|
@@ -13126,17 +13171,16 @@ var HistogramState = class {
|
|
|
13126
13171
|
return pipeArguments(this, arguments);
|
|
13127
13172
|
}
|
|
13128
13173
|
};
|
|
13129
|
-
var _a35, _b10;
|
|
13130
13174
|
var SummaryState = class {
|
|
13175
|
+
error;
|
|
13176
|
+
quantiles;
|
|
13177
|
+
count;
|
|
13178
|
+
min;
|
|
13179
|
+
max;
|
|
13180
|
+
sum;
|
|
13181
|
+
[MetricStateTypeId] = metricStateVariance;
|
|
13182
|
+
[SummaryStateTypeId] = SummaryStateTypeId;
|
|
13131
13183
|
constructor(error, quantiles, count, min3, max3, sum) {
|
|
13132
|
-
__publicField(this, "error");
|
|
13133
|
-
__publicField(this, "quantiles");
|
|
13134
|
-
__publicField(this, "count");
|
|
13135
|
-
__publicField(this, "min");
|
|
13136
|
-
__publicField(this, "max");
|
|
13137
|
-
__publicField(this, "sum");
|
|
13138
|
-
__publicField(this, _b10, metricStateVariance);
|
|
13139
|
-
__publicField(this, _a35, SummaryStateTypeId);
|
|
13140
13184
|
this.error = error;
|
|
13141
13185
|
this.quantiles = quantiles;
|
|
13142
13186
|
this.count = count;
|
|
@@ -13144,7 +13188,7 @@ var SummaryState = class {
|
|
|
13144
13188
|
this.max = max3;
|
|
13145
13189
|
this.sum = sum;
|
|
13146
13190
|
}
|
|
13147
|
-
[
|
|
13191
|
+
[symbol]() {
|
|
13148
13192
|
return pipe(hash(SummaryStateSymbolKey), combine(hash(this.error)), combine(hash(this.quantiles)), combine(hash(this.count)), combine(hash(this.min)), combine(hash(this.max)), combine(hash(this.sum)), cached(this));
|
|
13149
13193
|
}
|
|
13150
13194
|
[symbol2](that) {
|
|
@@ -13186,7 +13230,7 @@ var make25 = (options) => ({
|
|
|
13186
13230
|
var bigint03 = /* @__PURE__ */ BigInt(0);
|
|
13187
13231
|
var counter4 = (key) => {
|
|
13188
13232
|
let sum = key.keyType.bigint ? bigint03 : 0;
|
|
13189
|
-
const canUpdate = key.keyType.incremental ? key.keyType.bigint ? (value3) => value3 >= bigint03 : (value3) => value3 >= 0 : (
|
|
13233
|
+
const canUpdate = key.keyType.incremental ? key.keyType.bigint ? (value3) => value3 >= bigint03 : (value3) => value3 >= 0 : (_value) => true;
|
|
13190
13234
|
const update3 = (value3) => {
|
|
13191
13235
|
if (canUpdate(value3)) {
|
|
13192
13236
|
sum = sum + value3;
|
|
@@ -13485,13 +13529,9 @@ var unsafeMake5 = (metricKey, metricState) => {
|
|
|
13485
13529
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/internal/metric/registry.js
|
|
13486
13530
|
var MetricRegistrySymbolKey = "effect/MetricRegistry";
|
|
13487
13531
|
var MetricRegistryTypeId = /* @__PURE__ */ Symbol.for(MetricRegistrySymbolKey);
|
|
13488
|
-
var _a36;
|
|
13489
|
-
_a36 = MetricRegistryTypeId;
|
|
13490
13532
|
var MetricRegistryImpl = class {
|
|
13491
|
-
|
|
13492
|
-
|
|
13493
|
-
__publicField(this, "map", /* @__PURE__ */ empty15());
|
|
13494
|
-
}
|
|
13533
|
+
[MetricRegistryTypeId] = MetricRegistryTypeId;
|
|
13534
|
+
map = /* @__PURE__ */ empty15();
|
|
13495
13535
|
snapshot() {
|
|
13496
13536
|
const result = [];
|
|
13497
13537
|
for (const [key, hook] of this.map) {
|
|
@@ -13678,11 +13718,11 @@ var Direction = {
|
|
|
13678
13718
|
Backward: 1 << 0
|
|
13679
13719
|
};
|
|
13680
13720
|
var RedBlackTreeIterator = class _RedBlackTreeIterator {
|
|
13721
|
+
self;
|
|
13722
|
+
stack;
|
|
13723
|
+
direction;
|
|
13724
|
+
count = 0;
|
|
13681
13725
|
constructor(self, stack, direction) {
|
|
13682
|
-
__publicField(this, "self");
|
|
13683
|
-
__publicField(this, "stack");
|
|
13684
|
-
__publicField(this, "direction");
|
|
13685
|
-
__publicField(this, "count", 0);
|
|
13686
13726
|
this.self = self;
|
|
13687
13727
|
this.stack = stack;
|
|
13688
13728
|
this.direction = direction;
|
|
@@ -14569,13 +14609,11 @@ var supervisorVariance = {
|
|
|
14569
14609
|
/* c8 ignore next */
|
|
14570
14610
|
_T: (_) => _
|
|
14571
14611
|
};
|
|
14572
|
-
var
|
|
14573
|
-
|
|
14574
|
-
|
|
14612
|
+
var ProxySupervisor = class _ProxySupervisor {
|
|
14613
|
+
underlying;
|
|
14614
|
+
value0;
|
|
14615
|
+
[SupervisorTypeId] = supervisorVariance;
|
|
14575
14616
|
constructor(underlying, value0) {
|
|
14576
|
-
__publicField(this, "underlying");
|
|
14577
|
-
__publicField(this, "value0");
|
|
14578
|
-
__publicField(this, _a37, supervisorVariance);
|
|
14579
14617
|
this.underlying = underlying;
|
|
14580
14618
|
this.value0 = value0;
|
|
14581
14619
|
}
|
|
@@ -14604,15 +14642,12 @@ var _ProxySupervisor = class _ProxySupervisor {
|
|
|
14604
14642
|
return new Zip(this, right3);
|
|
14605
14643
|
}
|
|
14606
14644
|
};
|
|
14607
|
-
var
|
|
14608
|
-
|
|
14609
|
-
|
|
14610
|
-
|
|
14645
|
+
var Zip = class _Zip {
|
|
14646
|
+
left;
|
|
14647
|
+
right;
|
|
14648
|
+
_tag = "Zip";
|
|
14649
|
+
[SupervisorTypeId] = supervisorVariance;
|
|
14611
14650
|
constructor(left3, right3) {
|
|
14612
|
-
__publicField(this, "left");
|
|
14613
|
-
__publicField(this, "right");
|
|
14614
|
-
__publicField(this, "_tag", "Zip");
|
|
14615
|
-
__publicField(this, _a38, supervisorVariance);
|
|
14616
14651
|
this.left = left3;
|
|
14617
14652
|
this.right = right3;
|
|
14618
14653
|
}
|
|
@@ -14646,22 +14681,17 @@ var _Zip = class _Zip {
|
|
|
14646
14681
|
return new _Zip(this, right3);
|
|
14647
14682
|
}
|
|
14648
14683
|
};
|
|
14649
|
-
var Zip = _Zip;
|
|
14650
14684
|
var isZip = (self) => hasProperty(self, SupervisorTypeId) && isTagged(self, "Zip");
|
|
14651
|
-
var _a39;
|
|
14652
|
-
_a39 = SupervisorTypeId;
|
|
14653
14685
|
var Track = class {
|
|
14654
|
-
|
|
14655
|
-
|
|
14656
|
-
__publicField(this, "fibers", /* @__PURE__ */ new Set());
|
|
14657
|
-
}
|
|
14686
|
+
[SupervisorTypeId] = supervisorVariance;
|
|
14687
|
+
fibers = /* @__PURE__ */ new Set();
|
|
14658
14688
|
get value() {
|
|
14659
14689
|
return sync(() => Array.from(this.fibers));
|
|
14660
14690
|
}
|
|
14661
14691
|
onStart(_context, _effect, _parent, fiber) {
|
|
14662
14692
|
this.fibers.add(fiber);
|
|
14663
14693
|
}
|
|
14664
|
-
onEnd(
|
|
14694
|
+
onEnd(_value, fiber) {
|
|
14665
14695
|
this.fibers.delete(fiber);
|
|
14666
14696
|
}
|
|
14667
14697
|
onEffect(_fiber, _effect) {
|
|
@@ -14680,12 +14710,10 @@ var Track = class {
|
|
|
14680
14710
|
return execution();
|
|
14681
14711
|
}
|
|
14682
14712
|
};
|
|
14683
|
-
var _a40;
|
|
14684
|
-
_a40 = SupervisorTypeId;
|
|
14685
14713
|
var Const = class {
|
|
14714
|
+
effect;
|
|
14715
|
+
[SupervisorTypeId] = supervisorVariance;
|
|
14686
14716
|
constructor(effect) {
|
|
14687
|
-
__publicField(this, "effect");
|
|
14688
|
-
__publicField(this, _a40, supervisorVariance);
|
|
14689
14717
|
this.effect = effect;
|
|
14690
14718
|
}
|
|
14691
14719
|
get value() {
|
|
@@ -14693,7 +14721,7 @@ var Const = class {
|
|
|
14693
14721
|
}
|
|
14694
14722
|
onStart(_context, _effect, _parent, _fiber) {
|
|
14695
14723
|
}
|
|
14696
|
-
onEnd(
|
|
14724
|
+
onEnd(_value, _fiber) {
|
|
14697
14725
|
}
|
|
14698
14726
|
onEffect(_fiber, _effect) {
|
|
14699
14727
|
}
|
|
@@ -14711,12 +14739,10 @@ var Const = class {
|
|
|
14711
14739
|
return execution();
|
|
14712
14740
|
}
|
|
14713
14741
|
};
|
|
14714
|
-
var _a41;
|
|
14715
|
-
_a41 = SupervisorTypeId;
|
|
14716
14742
|
var FibersIn = class {
|
|
14743
|
+
ref;
|
|
14744
|
+
[SupervisorTypeId] = supervisorVariance;
|
|
14717
14745
|
constructor(ref) {
|
|
14718
|
-
__publicField(this, "ref");
|
|
14719
|
-
__publicField(this, _a41, supervisorVariance);
|
|
14720
14746
|
this.ref = ref;
|
|
14721
14747
|
}
|
|
14722
14748
|
get value() {
|
|
@@ -14725,7 +14751,7 @@ var FibersIn = class {
|
|
|
14725
14751
|
onStart(_context, _effect, _parent, fiber) {
|
|
14726
14752
|
pipe(this.ref, set2(pipe(get5(this.ref), add5(fiber))));
|
|
14727
14753
|
}
|
|
14728
|
-
onEnd(
|
|
14754
|
+
onEnd(_value, fiber) {
|
|
14729
14755
|
pipe(this.ref, set2(pipe(get5(this.ref), remove5(fiber))));
|
|
14730
14756
|
}
|
|
14731
14757
|
onEffect(_fiber, _effect) {
|
|
@@ -14940,35 +14966,31 @@ var runBlockedRequests = (self) => forEachSequentialDiscard(flatten3(self), (req
|
|
|
14940
14966
|
})), currentRequestMap, map15);
|
|
14941
14967
|
}, false, false));
|
|
14942
14968
|
var _version = /* @__PURE__ */ getCurrentVersion();
|
|
14943
|
-
var _a42, _b11;
|
|
14944
14969
|
var FiberRuntime = class extends Class2 {
|
|
14970
|
+
[FiberTypeId] = fiberVariance2;
|
|
14971
|
+
[RuntimeFiberTypeId] = runtimeFiberVariance;
|
|
14972
|
+
_fiberRefs;
|
|
14973
|
+
_fiberId;
|
|
14974
|
+
_queue = /* @__PURE__ */ new Array();
|
|
14975
|
+
_children = null;
|
|
14976
|
+
_observers = /* @__PURE__ */ new Array();
|
|
14977
|
+
_running = false;
|
|
14978
|
+
_stack = [];
|
|
14979
|
+
_asyncInterruptor = null;
|
|
14980
|
+
_asyncBlockingOn = null;
|
|
14981
|
+
_exitValue = null;
|
|
14982
|
+
_steps = [];
|
|
14983
|
+
_isYielding = false;
|
|
14984
|
+
currentRuntimeFlags;
|
|
14985
|
+
currentOpCount = 0;
|
|
14986
|
+
currentSupervisor;
|
|
14987
|
+
currentScheduler;
|
|
14988
|
+
currentTracer;
|
|
14989
|
+
currentSpan;
|
|
14990
|
+
currentContext;
|
|
14991
|
+
currentDefaultServices;
|
|
14945
14992
|
constructor(fiberId2, fiberRefs0, runtimeFlags0) {
|
|
14946
14993
|
super();
|
|
14947
|
-
__publicField(this, _b11, fiberVariance2);
|
|
14948
|
-
__publicField(this, _a42, runtimeFiberVariance);
|
|
14949
|
-
__publicField(this, "_fiberRefs");
|
|
14950
|
-
__publicField(this, "_fiberId");
|
|
14951
|
-
__publicField(this, "_queue", /* @__PURE__ */ new Array());
|
|
14952
|
-
__publicField(this, "_children", null);
|
|
14953
|
-
__publicField(this, "_observers", /* @__PURE__ */ new Array());
|
|
14954
|
-
__publicField(this, "_running", false);
|
|
14955
|
-
__publicField(this, "_stack", []);
|
|
14956
|
-
__publicField(this, "_asyncInterruptor", null);
|
|
14957
|
-
__publicField(this, "_asyncBlockingOn", null);
|
|
14958
|
-
__publicField(this, "_exitValue", null);
|
|
14959
|
-
__publicField(this, "_steps", []);
|
|
14960
|
-
__publicField(this, "_isYielding", false);
|
|
14961
|
-
__publicField(this, "currentRuntimeFlags");
|
|
14962
|
-
__publicField(this, "currentOpCount", 0);
|
|
14963
|
-
__publicField(this, "currentSupervisor");
|
|
14964
|
-
__publicField(this, "currentScheduler");
|
|
14965
|
-
__publicField(this, "currentTracer");
|
|
14966
|
-
__publicField(this, "currentSpan");
|
|
14967
|
-
__publicField(this, "currentContext");
|
|
14968
|
-
__publicField(this, "currentDefaultServices");
|
|
14969
|
-
__publicField(this, "run", () => {
|
|
14970
|
-
this.drainQueueOnCurrentThread();
|
|
14971
|
-
});
|
|
14972
14994
|
this.currentRuntimeFlags = runtimeFlags0;
|
|
14973
14995
|
this._fiberId = fiberId2;
|
|
14974
14996
|
this._fiberRefs = fiberRefs0;
|
|
@@ -15646,7 +15668,7 @@ var FiberRuntime = class extends Class2 {
|
|
|
15646
15668
|
frame = this.popStack();
|
|
15647
15669
|
}
|
|
15648
15670
|
}
|
|
15649
|
-
[
|
|
15671
|
+
[OP_TAG](op) {
|
|
15650
15672
|
return sync(() => unsafeGet3(this.currentContext, op));
|
|
15651
15673
|
}
|
|
15652
15674
|
["Left"](op) {
|
|
@@ -15897,6 +15919,9 @@ var FiberRuntime = class extends Class2 {
|
|
|
15897
15919
|
}
|
|
15898
15920
|
}
|
|
15899
15921
|
}
|
|
15922
|
+
run = () => {
|
|
15923
|
+
this.drainQueueOnCurrentThread();
|
|
15924
|
+
};
|
|
15900
15925
|
};
|
|
15901
15926
|
var currentMinimumLogLevel = /* @__PURE__ */ globalValue("effect/FiberRef/currentMinimumLogLevel", () => fiberRefUnsafeMake(fromLiteral("Info")));
|
|
15902
15927
|
var loggerWithConsoleLog = (self) => makeLogger((opts) => {
|
|
@@ -16351,10 +16376,7 @@ var Error3 = /* @__PURE__ */ function() {
|
|
|
16351
16376
|
}();
|
|
16352
16377
|
var TaggedError = (tag2) => {
|
|
16353
16378
|
class Base3 extends Error3 {
|
|
16354
|
-
|
|
16355
|
-
super(...arguments);
|
|
16356
|
-
__publicField(this, "_tag", tag2);
|
|
16357
|
-
}
|
|
16379
|
+
_tag = tag2;
|
|
16358
16380
|
}
|
|
16359
16381
|
;
|
|
16360
16382
|
Base3.prototype.name = tag2;
|
|
@@ -16754,10 +16776,10 @@ var unsafeRunSync = (runtime4) => (effect) => {
|
|
|
16754
16776
|
}
|
|
16755
16777
|
};
|
|
16756
16778
|
var AsyncFiberExceptionImpl = class extends Error {
|
|
16779
|
+
fiber;
|
|
16780
|
+
_tag = "AsyncFiberException";
|
|
16757
16781
|
constructor(fiber) {
|
|
16758
16782
|
super(`Fiber #${fiber.id().id} cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work`);
|
|
16759
|
-
__publicField(this, "fiber");
|
|
16760
|
-
__publicField(this, "_tag", "AsyncFiberException");
|
|
16761
16783
|
this.fiber = fiber;
|
|
16762
16784
|
this.name = this._tag;
|
|
16763
16785
|
this.stack = this.message;
|
|
@@ -16772,13 +16794,12 @@ var asyncFiberException = (fiber) => {
|
|
|
16772
16794
|
};
|
|
16773
16795
|
var FiberFailureId = /* @__PURE__ */ Symbol.for("effect/Runtime/FiberFailure");
|
|
16774
16796
|
var FiberFailureCauseId = /* @__PURE__ */ Symbol.for("effect/Runtime/FiberFailure/Cause");
|
|
16775
|
-
var _a43, _b12;
|
|
16776
16797
|
var FiberFailureImpl = class extends Error {
|
|
16798
|
+
[FiberFailureId];
|
|
16799
|
+
[FiberFailureCauseId];
|
|
16777
16800
|
constructor(cause) {
|
|
16778
16801
|
const head4 = prettyErrors(cause)[0];
|
|
16779
16802
|
super(head4?.message || "An error has occurred");
|
|
16780
|
-
__publicField(this, _b12);
|
|
16781
|
-
__publicField(this, _a43);
|
|
16782
16803
|
this[FiberFailureId] = FiberFailureId;
|
|
16783
16804
|
this[FiberFailureCauseId] = cause;
|
|
16784
16805
|
this.name = head4 ? `(FiberFailure) ${head4.name}` : "FiberFailure";
|
|
@@ -16797,7 +16818,7 @@ var FiberFailureImpl = class extends Error {
|
|
|
16797
16818
|
renderErrorCause: true
|
|
16798
16819
|
});
|
|
16799
16820
|
}
|
|
16800
|
-
[
|
|
16821
|
+
[NodeInspectSymbol]() {
|
|
16801
16822
|
return this.toString();
|
|
16802
16823
|
}
|
|
16803
16824
|
};
|
|
@@ -16877,10 +16898,10 @@ var unsafeRunPromiseExit = (runtime4) => (effect, options) => new Promise((resol
|
|
|
16877
16898
|
}
|
|
16878
16899
|
});
|
|
16879
16900
|
var RuntimeImpl = class {
|
|
16901
|
+
context;
|
|
16902
|
+
runtimeFlags;
|
|
16903
|
+
fiberRefs;
|
|
16880
16904
|
constructor(context3, runtimeFlags2, fiberRefs2) {
|
|
16881
|
-
__publicField(this, "context");
|
|
16882
|
-
__publicField(this, "runtimeFlags");
|
|
16883
|
-
__publicField(this, "fiberRefs");
|
|
16884
16905
|
this.context = context3;
|
|
16885
16906
|
this.runtimeFlags = runtimeFlags2;
|
|
16886
16907
|
this.fiberRefs = fiberRefs2;
|
|
@@ -17195,57 +17216,57 @@ var EncodeException2 = EncodeException;
|
|
|
17195
17216
|
|
|
17196
17217
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/ParseResult.js
|
|
17197
17218
|
var Pointer = class {
|
|
17219
|
+
path;
|
|
17220
|
+
actual;
|
|
17221
|
+
issue;
|
|
17222
|
+
/**
|
|
17223
|
+
* @since 3.10.0
|
|
17224
|
+
*/
|
|
17225
|
+
_tag = "Pointer";
|
|
17198
17226
|
constructor(path2, actual, issue) {
|
|
17199
|
-
__publicField(this, "path");
|
|
17200
|
-
__publicField(this, "actual");
|
|
17201
|
-
__publicField(this, "issue");
|
|
17202
|
-
/**
|
|
17203
|
-
* @since 3.10.0
|
|
17204
|
-
*/
|
|
17205
|
-
__publicField(this, "_tag", "Pointer");
|
|
17206
17227
|
this.path = path2;
|
|
17207
17228
|
this.actual = actual;
|
|
17208
17229
|
this.issue = issue;
|
|
17209
17230
|
}
|
|
17210
17231
|
};
|
|
17211
17232
|
var Unexpected = class {
|
|
17233
|
+
actual;
|
|
17234
|
+
message;
|
|
17235
|
+
/**
|
|
17236
|
+
* @since 3.10.0
|
|
17237
|
+
*/
|
|
17238
|
+
_tag = "Unexpected";
|
|
17212
17239
|
constructor(actual, message) {
|
|
17213
|
-
__publicField(this, "actual");
|
|
17214
|
-
__publicField(this, "message");
|
|
17215
|
-
/**
|
|
17216
|
-
* @since 3.10.0
|
|
17217
|
-
*/
|
|
17218
|
-
__publicField(this, "_tag", "Unexpected");
|
|
17219
17240
|
this.actual = actual;
|
|
17220
17241
|
this.message = message;
|
|
17221
17242
|
}
|
|
17222
17243
|
};
|
|
17223
17244
|
var Missing = class {
|
|
17245
|
+
ast;
|
|
17246
|
+
message;
|
|
17247
|
+
/**
|
|
17248
|
+
* @since 3.10.0
|
|
17249
|
+
*/
|
|
17250
|
+
_tag = "Missing";
|
|
17251
|
+
/**
|
|
17252
|
+
* @since 3.10.0
|
|
17253
|
+
*/
|
|
17254
|
+
actual = void 0;
|
|
17224
17255
|
constructor(ast, message) {
|
|
17225
|
-
__publicField(this, "ast");
|
|
17226
|
-
__publicField(this, "message");
|
|
17227
|
-
/**
|
|
17228
|
-
* @since 3.10.0
|
|
17229
|
-
*/
|
|
17230
|
-
__publicField(this, "_tag", "Missing");
|
|
17231
|
-
/**
|
|
17232
|
-
* @since 3.10.0
|
|
17233
|
-
*/
|
|
17234
|
-
__publicField(this, "actual");
|
|
17235
17256
|
this.ast = ast;
|
|
17236
17257
|
this.message = message;
|
|
17237
17258
|
}
|
|
17238
17259
|
};
|
|
17239
17260
|
var Composite2 = class {
|
|
17261
|
+
ast;
|
|
17262
|
+
actual;
|
|
17263
|
+
issues;
|
|
17264
|
+
output;
|
|
17265
|
+
/**
|
|
17266
|
+
* @since 3.10.0
|
|
17267
|
+
*/
|
|
17268
|
+
_tag = "Composite";
|
|
17240
17269
|
constructor(ast, actual, issues, output) {
|
|
17241
|
-
__publicField(this, "ast");
|
|
17242
|
-
__publicField(this, "actual");
|
|
17243
|
-
__publicField(this, "issues");
|
|
17244
|
-
__publicField(this, "output");
|
|
17245
|
-
/**
|
|
17246
|
-
* @since 3.10.0
|
|
17247
|
-
*/
|
|
17248
|
-
__publicField(this, "_tag", "Composite");
|
|
17249
17270
|
this.ast = ast;
|
|
17250
17271
|
this.actual = actual;
|
|
17251
17272
|
this.issues = issues;
|
|
@@ -17253,15 +17274,15 @@ var Composite2 = class {
|
|
|
17253
17274
|
}
|
|
17254
17275
|
};
|
|
17255
17276
|
var Refinement2 = class {
|
|
17277
|
+
ast;
|
|
17278
|
+
actual;
|
|
17279
|
+
kind;
|
|
17280
|
+
issue;
|
|
17281
|
+
/**
|
|
17282
|
+
* @since 3.10.0
|
|
17283
|
+
*/
|
|
17284
|
+
_tag = "Refinement";
|
|
17256
17285
|
constructor(ast, actual, kind, issue) {
|
|
17257
|
-
__publicField(this, "ast");
|
|
17258
|
-
__publicField(this, "actual");
|
|
17259
|
-
__publicField(this, "kind");
|
|
17260
|
-
__publicField(this, "issue");
|
|
17261
|
-
/**
|
|
17262
|
-
* @since 3.10.0
|
|
17263
|
-
*/
|
|
17264
|
-
__publicField(this, "_tag", "Refinement");
|
|
17265
17286
|
this.ast = ast;
|
|
17266
17287
|
this.actual = actual;
|
|
17267
17288
|
this.kind = kind;
|
|
@@ -17269,15 +17290,15 @@ var Refinement2 = class {
|
|
|
17269
17290
|
}
|
|
17270
17291
|
};
|
|
17271
17292
|
var Transformation2 = class {
|
|
17293
|
+
ast;
|
|
17294
|
+
actual;
|
|
17295
|
+
kind;
|
|
17296
|
+
issue;
|
|
17297
|
+
/**
|
|
17298
|
+
* @since 3.10.0
|
|
17299
|
+
*/
|
|
17300
|
+
_tag = "Transformation";
|
|
17272
17301
|
constructor(ast, actual, kind, issue) {
|
|
17273
|
-
__publicField(this, "ast");
|
|
17274
|
-
__publicField(this, "actual");
|
|
17275
|
-
__publicField(this, "kind");
|
|
17276
|
-
__publicField(this, "issue");
|
|
17277
|
-
/**
|
|
17278
|
-
* @since 3.10.0
|
|
17279
|
-
*/
|
|
17280
|
-
__publicField(this, "_tag", "Transformation");
|
|
17281
17302
|
this.ast = ast;
|
|
17282
17303
|
this.actual = actual;
|
|
17283
17304
|
this.kind = kind;
|
|
@@ -17285,43 +17306,39 @@ var Transformation2 = class {
|
|
|
17285
17306
|
}
|
|
17286
17307
|
};
|
|
17287
17308
|
var Type2 = class {
|
|
17309
|
+
ast;
|
|
17310
|
+
actual;
|
|
17311
|
+
message;
|
|
17312
|
+
/**
|
|
17313
|
+
* @since 3.10.0
|
|
17314
|
+
*/
|
|
17315
|
+
_tag = "Type";
|
|
17288
17316
|
constructor(ast, actual, message) {
|
|
17289
|
-
__publicField(this, "ast");
|
|
17290
|
-
__publicField(this, "actual");
|
|
17291
|
-
__publicField(this, "message");
|
|
17292
|
-
/**
|
|
17293
|
-
* @since 3.10.0
|
|
17294
|
-
*/
|
|
17295
|
-
__publicField(this, "_tag", "Type");
|
|
17296
17317
|
this.ast = ast;
|
|
17297
17318
|
this.actual = actual;
|
|
17298
17319
|
this.message = message;
|
|
17299
17320
|
}
|
|
17300
17321
|
};
|
|
17301
17322
|
var Forbidden = class {
|
|
17323
|
+
ast;
|
|
17324
|
+
actual;
|
|
17325
|
+
message;
|
|
17326
|
+
/**
|
|
17327
|
+
* @since 3.10.0
|
|
17328
|
+
*/
|
|
17329
|
+
_tag = "Forbidden";
|
|
17302
17330
|
constructor(ast, actual, message) {
|
|
17303
|
-
__publicField(this, "ast");
|
|
17304
|
-
__publicField(this, "actual");
|
|
17305
|
-
__publicField(this, "message");
|
|
17306
|
-
/**
|
|
17307
|
-
* @since 3.10.0
|
|
17308
|
-
*/
|
|
17309
|
-
__publicField(this, "_tag", "Forbidden");
|
|
17310
17331
|
this.ast = ast;
|
|
17311
17332
|
this.actual = actual;
|
|
17312
17333
|
this.message = message;
|
|
17313
17334
|
}
|
|
17314
17335
|
};
|
|
17315
17336
|
var ParseErrorTypeId = /* @__PURE__ */ Symbol.for("effect/Schema/ParseErrorTypeId");
|
|
17316
|
-
var _a44;
|
|
17317
17337
|
var ParseError = class extends (/* @__PURE__ */ TaggedError("ParseError")) {
|
|
17318
|
-
|
|
17319
|
-
|
|
17320
|
-
|
|
17321
|
-
|
|
17322
|
-
*/
|
|
17323
|
-
__publicField(this, _a44, ParseErrorTypeId);
|
|
17324
|
-
}
|
|
17338
|
+
/**
|
|
17339
|
+
* @since 3.10.0
|
|
17340
|
+
*/
|
|
17341
|
+
[ParseErrorTypeId] = ParseErrorTypeId;
|
|
17325
17342
|
get message() {
|
|
17326
17343
|
return this.toString();
|
|
17327
17344
|
}
|
|
@@ -17343,7 +17360,7 @@ var ParseError = class extends (/* @__PURE__ */ TaggedError("ParseError")) {
|
|
|
17343
17360
|
/**
|
|
17344
17361
|
* @since 3.10.0
|
|
17345
17362
|
*/
|
|
17346
|
-
[
|
|
17363
|
+
[NodeInspectSymbol]() {
|
|
17347
17364
|
return this.toJSON();
|
|
17348
17365
|
}
|
|
17349
17366
|
};
|
|
@@ -18736,22 +18753,22 @@ var omit3 = /* @__PURE__ */ dual((args2) => isObject(args2[0]), (s, ...keys5) =>
|
|
|
18736
18753
|
|
|
18737
18754
|
// ../../node_modules/.pnpm/effect@3.12.10/node_modules/effect/dist/esm/Schema.js
|
|
18738
18755
|
var TypeId15 = /* @__PURE__ */ Symbol.for("effect/Schema");
|
|
18739
|
-
var make34 = (ast) => {
|
|
18740
|
-
|
|
18741
|
-
|
|
18742
|
-
|
|
18743
|
-
|
|
18744
|
-
|
|
18745
|
-
|
|
18746
|
-
|
|
18747
|
-
|
|
18748
|
-
|
|
18749
|
-
|
|
18750
|
-
|
|
18751
|
-
|
|
18752
|
-
|
|
18753
|
-
|
|
18754
|
-
|
|
18756
|
+
var make34 = (ast) => class SchemaClass {
|
|
18757
|
+
[TypeId15] = variance5;
|
|
18758
|
+
static ast = ast;
|
|
18759
|
+
static annotations(annotations3) {
|
|
18760
|
+
return make34(mergeSchemaAnnotations(this.ast, annotations3));
|
|
18761
|
+
}
|
|
18762
|
+
static pipe() {
|
|
18763
|
+
return pipeArguments(this, arguments);
|
|
18764
|
+
}
|
|
18765
|
+
static toString() {
|
|
18766
|
+
return String(ast);
|
|
18767
|
+
}
|
|
18768
|
+
static Type;
|
|
18769
|
+
static Encoded;
|
|
18770
|
+
static Context;
|
|
18771
|
+
static [TypeId15] = variance5;
|
|
18755
18772
|
};
|
|
18756
18773
|
var variance5 = {
|
|
18757
18774
|
/* c8 ignore next */
|
|
@@ -18847,13 +18864,11 @@ var validatePromise = (schema, options) => {
|
|
|
18847
18864
|
};
|
|
18848
18865
|
var isSchema = (u) => hasProperty(u, TypeId15) && isObject(u[TypeId15]);
|
|
18849
18866
|
var getDefaultLiteralAST = (literals) => isMembers(literals) ? Union.make(mapMembers(literals, (literal2) => new Literal(literal2))) : new Literal(literals[0]);
|
|
18850
|
-
var makeLiteralClass = (literals, ast = getDefaultLiteralAST(literals)) => {
|
|
18851
|
-
|
|
18852
|
-
|
|
18853
|
-
|
|
18854
|
-
|
|
18855
|
-
}
|
|
18856
|
-
}, __publicField(_a47, "literals", [...literals]), _a47;
|
|
18867
|
+
var makeLiteralClass = (literals, ast = getDefaultLiteralAST(literals)) => class LiteralClass extends make34(ast) {
|
|
18868
|
+
static annotations(annotations3) {
|
|
18869
|
+
return makeLiteralClass(this.literals, mergeSchemaAnnotations(this.ast, annotations3));
|
|
18870
|
+
}
|
|
18871
|
+
static literals = [...literals];
|
|
18857
18872
|
};
|
|
18858
18873
|
function Literal2(...literals) {
|
|
18859
18874
|
return isNonEmptyReadonlyArray(literals) ? makeLiteralClass(literals) : Never;
|
|
@@ -18861,15 +18876,13 @@ function Literal2(...literals) {
|
|
|
18861
18876
|
var pickLiteral = (...literals) => (_schema) => Literal2(...literals);
|
|
18862
18877
|
var UniqueSymbolFromSelf = (symbol3) => make34(new UniqueSymbol(symbol3));
|
|
18863
18878
|
var getDefaultEnumsAST = (enums) => new Enums(Object.keys(enums).filter((key) => typeof enums[enums[key]] !== "number").map((key) => [key, enums[key]]));
|
|
18864
|
-
var makeEnumsClass = (enums, ast = getDefaultEnumsAST(enums)) => {
|
|
18865
|
-
|
|
18866
|
-
|
|
18867
|
-
|
|
18868
|
-
|
|
18869
|
-
}
|
|
18870
|
-
}, __publicField(_a47, "enums", {
|
|
18879
|
+
var makeEnumsClass = (enums, ast = getDefaultEnumsAST(enums)) => class EnumsClass extends make34(ast) {
|
|
18880
|
+
static annotations(annotations3) {
|
|
18881
|
+
return makeEnumsClass(this.enums, mergeSchemaAnnotations(this.ast, annotations3));
|
|
18882
|
+
}
|
|
18883
|
+
static enums = {
|
|
18871
18884
|
...enums
|
|
18872
|
-
}
|
|
18885
|
+
};
|
|
18873
18886
|
};
|
|
18874
18887
|
var Enums2 = (enums) => makeEnumsClass(enums);
|
|
18875
18888
|
var TemplateLiteral2 = (...[head4, ...tail]) => {
|
|
@@ -18947,7 +18960,6 @@ function getTemplateLiteralParserCoercedElement(encoded, schema) {
|
|
|
18947
18960
|
}
|
|
18948
18961
|
}
|
|
18949
18962
|
var TemplateLiteralParser = (...params) => {
|
|
18950
|
-
var _a47;
|
|
18951
18963
|
const encodedSchemas = [];
|
|
18952
18964
|
const elements = [];
|
|
18953
18965
|
const schemas = [];
|
|
@@ -18974,7 +18986,7 @@ var TemplateLiteralParser = (...params) => {
|
|
|
18974
18986
|
[AutoTitleAnnotationId]: format6(Tuple(...schemas))
|
|
18975
18987
|
});
|
|
18976
18988
|
}
|
|
18977
|
-
return
|
|
18989
|
+
return class TemplateLiteralParserClass extends transformOrFail(from, to, {
|
|
18978
18990
|
strict: false,
|
|
18979
18991
|
decode: (s, _, ast) => {
|
|
18980
18992
|
const match10 = re.exec(s);
|
|
@@ -18982,7 +18994,8 @@ var TemplateLiteralParser = (...params) => {
|
|
|
18982
18994
|
},
|
|
18983
18995
|
encode: (tuple2) => succeed6(tuple2.join(""))
|
|
18984
18996
|
}) {
|
|
18985
|
-
|
|
18997
|
+
static params = params.slice();
|
|
18998
|
+
};
|
|
18986
18999
|
};
|
|
18987
19000
|
var declareConstructor = (typeParameters, options, annotations3) => make34(new Declaration(typeParameters.map((tp) => tp.ast), (...typeParameters2) => options.decode(...typeParameters2.map(make34)), (...typeParameters2) => options.encode(...typeParameters2.map(make34)), toASTAnnotations(annotations3)));
|
|
18988
19001
|
var declarePrimitive = (is2, annotations3) => {
|
|
@@ -19048,13 +19061,11 @@ var Boolean$ = class extends (/* @__PURE__ */ make34(booleanKeyword)) {
|
|
|
19048
19061
|
var Object$ = class extends (/* @__PURE__ */ make34(objectKeyword)) {
|
|
19049
19062
|
};
|
|
19050
19063
|
var getDefaultUnionAST = (members) => Union.make(members.map((m) => m.ast));
|
|
19051
|
-
var makeUnionClass = (members, ast = getDefaultUnionAST(members)) => {
|
|
19052
|
-
|
|
19053
|
-
|
|
19054
|
-
|
|
19055
|
-
|
|
19056
|
-
}
|
|
19057
|
-
}, __publicField(_a47, "members", [...members]), _a47;
|
|
19064
|
+
var makeUnionClass = (members, ast = getDefaultUnionAST(members)) => class UnionClass extends make34(ast) {
|
|
19065
|
+
static annotations(annotations3) {
|
|
19066
|
+
return makeUnionClass(this.members, mergeSchemaAnnotations(this.ast, annotations3));
|
|
19067
|
+
}
|
|
19068
|
+
static members = [...members];
|
|
19058
19069
|
};
|
|
19059
19070
|
function Union2(...members) {
|
|
19060
19071
|
return isMembers(members) ? makeUnionClass(members) : isNonEmptyReadonlyArray(members) ? members[0] : Never;
|
|
@@ -19065,14 +19076,12 @@ var NullishOr = (self) => Union2(self, Null, Undefined);
|
|
|
19065
19076
|
var keyof2 = (self) => make34(keyof(self.ast));
|
|
19066
19077
|
var element = (self) => new ElementImpl(new OptionalType(self.ast, false), self);
|
|
19067
19078
|
var optionalElement = (self) => new ElementImpl(new OptionalType(self.ast, true), self);
|
|
19068
|
-
var
|
|
19069
|
-
|
|
19070
|
-
|
|
19079
|
+
var ElementImpl = class _ElementImpl {
|
|
19080
|
+
ast;
|
|
19081
|
+
from;
|
|
19082
|
+
[TypeId15];
|
|
19083
|
+
_Token;
|
|
19071
19084
|
constructor(ast, from) {
|
|
19072
|
-
__publicField(this, "ast");
|
|
19073
|
-
__publicField(this, "from");
|
|
19074
|
-
__publicField(this, _a45);
|
|
19075
|
-
__publicField(this, "_Token");
|
|
19076
19085
|
this.ast = ast;
|
|
19077
19086
|
this.from = from;
|
|
19078
19087
|
}
|
|
@@ -19086,35 +19095,29 @@ var _ElementImpl = class _ElementImpl {
|
|
|
19086
19095
|
return `${this.ast.type}${this.ast.isOptional ? "?" : ""}`;
|
|
19087
19096
|
}
|
|
19088
19097
|
};
|
|
19089
|
-
var ElementImpl = _ElementImpl;
|
|
19090
19098
|
var getDefaultTupleTypeAST = (elements, rest) => new TupleType(elements.map((el) => isSchema(el) ? new OptionalType(el.ast, false) : el.ast), rest.map((el) => isSchema(el) ? new Type(el.ast) : el.ast), true);
|
|
19091
|
-
var makeTupleTypeClass = (elements, rest, ast = getDefaultTupleTypeAST(elements, rest)) => {
|
|
19092
|
-
|
|
19093
|
-
|
|
19094
|
-
|
|
19095
|
-
|
|
19096
|
-
|
|
19097
|
-
}, __publicField(_a47, "elements", [...elements]), __publicField(_a47, "rest", [...rest]), _a47;
|
|
19099
|
+
var makeTupleTypeClass = (elements, rest, ast = getDefaultTupleTypeAST(elements, rest)) => class TupleTypeClass extends make34(ast) {
|
|
19100
|
+
static annotations(annotations3) {
|
|
19101
|
+
return makeTupleTypeClass(this.elements, this.rest, mergeSchemaAnnotations(this.ast, annotations3));
|
|
19102
|
+
}
|
|
19103
|
+
static elements = [...elements];
|
|
19104
|
+
static rest = [...rest];
|
|
19098
19105
|
};
|
|
19099
19106
|
function Tuple(...args2) {
|
|
19100
19107
|
return Array.isArray(args2[0]) ? makeTupleTypeClass(args2[0], args2.slice(1)) : makeTupleTypeClass(args2, []);
|
|
19101
19108
|
}
|
|
19102
|
-
var makeArrayClass = (value3, ast) => {
|
|
19103
|
-
|
|
19104
|
-
|
|
19105
|
-
|
|
19106
|
-
|
|
19107
|
-
}
|
|
19108
|
-
}, __publicField(_a47, "value", value3), _a47;
|
|
19109
|
+
var makeArrayClass = (value3, ast) => class ArrayClass extends makeTupleTypeClass([], [value3], ast) {
|
|
19110
|
+
static annotations(annotations3) {
|
|
19111
|
+
return makeArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations3));
|
|
19112
|
+
}
|
|
19113
|
+
static value = value3;
|
|
19109
19114
|
};
|
|
19110
19115
|
var Array$ = (value3) => makeArrayClass(value3);
|
|
19111
|
-
var makeNonEmptyArrayClass = (value3, ast) => {
|
|
19112
|
-
|
|
19113
|
-
|
|
19114
|
-
|
|
19115
|
-
|
|
19116
|
-
}
|
|
19117
|
-
}, __publicField(_a47, "value", value3), _a47;
|
|
19116
|
+
var makeNonEmptyArrayClass = (value3, ast) => class NonEmptyArrayClass extends makeTupleTypeClass([value3], [value3], ast) {
|
|
19117
|
+
static annotations(annotations3) {
|
|
19118
|
+
return makeNonEmptyArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations3));
|
|
19119
|
+
}
|
|
19120
|
+
static value = value3;
|
|
19118
19121
|
};
|
|
19119
19122
|
var NonEmptyArray = (value3) => makeNonEmptyArrayClass(value3);
|
|
19120
19123
|
var ArrayEnsure = (value3) => {
|
|
@@ -19137,14 +19140,14 @@ var NonEmptyArrayEnsure = (value3) => {
|
|
|
19137
19140
|
};
|
|
19138
19141
|
var formatPropertySignatureToken = (isOptional) => isOptional ? '"?:"' : '":"';
|
|
19139
19142
|
var PropertySignatureDeclaration = class extends OptionalType {
|
|
19143
|
+
isReadonly;
|
|
19144
|
+
defaultValue;
|
|
19145
|
+
/**
|
|
19146
|
+
* @since 3.10.0
|
|
19147
|
+
*/
|
|
19148
|
+
_tag = "PropertySignatureDeclaration";
|
|
19140
19149
|
constructor(type, isOptional, isReadonly, annotations3, defaultValue) {
|
|
19141
19150
|
super(type, isOptional, annotations3);
|
|
19142
|
-
__publicField(this, "isReadonly");
|
|
19143
|
-
__publicField(this, "defaultValue");
|
|
19144
|
-
/**
|
|
19145
|
-
* @since 3.10.0
|
|
19146
|
-
*/
|
|
19147
|
-
__publicField(this, "_tag", "PropertySignatureDeclaration");
|
|
19148
19151
|
this.isReadonly = isReadonly;
|
|
19149
19152
|
this.defaultValue = defaultValue;
|
|
19150
19153
|
}
|
|
@@ -19158,19 +19161,19 @@ var PropertySignatureDeclaration = class extends OptionalType {
|
|
|
19158
19161
|
}
|
|
19159
19162
|
};
|
|
19160
19163
|
var FromPropertySignature = class extends OptionalType {
|
|
19164
|
+
isReadonly;
|
|
19165
|
+
fromKey;
|
|
19161
19166
|
constructor(type, isOptional, isReadonly, annotations3, fromKey2) {
|
|
19162
19167
|
super(type, isOptional, annotations3);
|
|
19163
|
-
__publicField(this, "isReadonly");
|
|
19164
|
-
__publicField(this, "fromKey");
|
|
19165
19168
|
this.isReadonly = isReadonly;
|
|
19166
19169
|
this.fromKey = fromKey2;
|
|
19167
19170
|
}
|
|
19168
19171
|
};
|
|
19169
19172
|
var ToPropertySignature = class extends OptionalType {
|
|
19173
|
+
isReadonly;
|
|
19174
|
+
defaultValue;
|
|
19170
19175
|
constructor(type, isOptional, isReadonly, annotations3, defaultValue) {
|
|
19171
19176
|
super(type, isOptional, annotations3);
|
|
19172
|
-
__publicField(this, "isReadonly");
|
|
19173
|
-
__publicField(this, "defaultValue");
|
|
19174
19177
|
this.isReadonly = isReadonly;
|
|
19175
19178
|
this.defaultValue = defaultValue;
|
|
19176
19179
|
}
|
|
@@ -19185,15 +19188,15 @@ var formatPropertyKey2 = (p) => {
|
|
|
19185
19188
|
return String(p);
|
|
19186
19189
|
};
|
|
19187
19190
|
var PropertySignatureTransformation2 = class {
|
|
19191
|
+
from;
|
|
19192
|
+
to;
|
|
19193
|
+
decode;
|
|
19194
|
+
encode;
|
|
19195
|
+
/**
|
|
19196
|
+
* @since 3.10.0
|
|
19197
|
+
*/
|
|
19198
|
+
_tag = "PropertySignatureTransformation";
|
|
19188
19199
|
constructor(from, to, decode6, encode5) {
|
|
19189
|
-
__publicField(this, "from");
|
|
19190
|
-
__publicField(this, "to");
|
|
19191
|
-
__publicField(this, "decode");
|
|
19192
|
-
__publicField(this, "encode");
|
|
19193
|
-
/**
|
|
19194
|
-
* @since 3.10.0
|
|
19195
|
-
*/
|
|
19196
|
-
__publicField(this, "_tag", "PropertySignatureTransformation");
|
|
19197
19200
|
this.from = from;
|
|
19198
19201
|
this.to = to;
|
|
19199
19202
|
this.decode = decode6;
|
|
@@ -19224,17 +19227,15 @@ var mergeSignatureAnnotations = (ast, annotations3) => {
|
|
|
19224
19227
|
};
|
|
19225
19228
|
var PropertySignatureTypeId = /* @__PURE__ */ Symbol.for("effect/PropertySignature");
|
|
19226
19229
|
var isPropertySignature = (u) => hasProperty(u, PropertySignatureTypeId);
|
|
19227
|
-
var
|
|
19228
|
-
|
|
19229
|
-
|
|
19230
|
+
var PropertySignatureImpl = class _PropertySignatureImpl {
|
|
19231
|
+
ast;
|
|
19232
|
+
[TypeId15];
|
|
19233
|
+
[PropertySignatureTypeId] = null;
|
|
19234
|
+
_TypeToken;
|
|
19235
|
+
_Key;
|
|
19236
|
+
_EncodedToken;
|
|
19237
|
+
_HasDefault;
|
|
19230
19238
|
constructor(ast) {
|
|
19231
|
-
__publicField(this, "ast");
|
|
19232
|
-
__publicField(this, _b13);
|
|
19233
|
-
__publicField(this, _a46, null);
|
|
19234
|
-
__publicField(this, "_TypeToken");
|
|
19235
|
-
__publicField(this, "_Key");
|
|
19236
|
-
__publicField(this, "_EncodedToken");
|
|
19237
|
-
__publicField(this, "_HasDefault");
|
|
19238
19239
|
this.ast = ast;
|
|
19239
19240
|
}
|
|
19240
19241
|
pipe() {
|
|
@@ -19247,12 +19248,11 @@ var _PropertySignatureImpl = class _PropertySignatureImpl {
|
|
|
19247
19248
|
return String(this.ast);
|
|
19248
19249
|
}
|
|
19249
19250
|
};
|
|
19250
|
-
var PropertySignatureImpl = _PropertySignatureImpl;
|
|
19251
19251
|
var makePropertySignature = (ast) => new PropertySignatureImpl(ast);
|
|
19252
19252
|
var PropertySignatureWithFromImpl = class _PropertySignatureWithFromImpl extends PropertySignatureImpl {
|
|
19253
|
+
from;
|
|
19253
19254
|
constructor(ast, from) {
|
|
19254
19255
|
super(ast);
|
|
19255
|
-
__publicField(this, "from");
|
|
19256
19256
|
this.from = from;
|
|
19257
19257
|
}
|
|
19258
19258
|
annotations(annotations3) {
|
|
@@ -19490,25 +19490,27 @@ var lazilyMergeDefaults = (fields, out) => {
|
|
|
19490
19490
|
return out;
|
|
19491
19491
|
};
|
|
19492
19492
|
var makeTypeLiteralClass = (fields, records, ast = getDefaultTypeLiteralAST(fields, records)) => {
|
|
19493
|
-
|
|
19494
|
-
return _a47 = class extends make34(ast) {
|
|
19493
|
+
return class TypeLiteralClass extends make34(ast) {
|
|
19495
19494
|
static annotations(annotations3) {
|
|
19496
19495
|
return makeTypeLiteralClass(this.fields, this.records, mergeSchemaAnnotations(this.ast, annotations3));
|
|
19497
19496
|
}
|
|
19497
|
+
static fields = {
|
|
19498
|
+
...fields
|
|
19499
|
+
};
|
|
19500
|
+
static records = [...records];
|
|
19501
|
+
static make = (props, options) => {
|
|
19502
|
+
const propsWithDefaults = lazilyMergeDefaults(fields, {
|
|
19503
|
+
...props
|
|
19504
|
+
});
|
|
19505
|
+
return getDisableValidationMakeOption(options) ? propsWithDefaults : validateSync(this)(propsWithDefaults);
|
|
19506
|
+
};
|
|
19498
19507
|
static pick(...keys5) {
|
|
19499
19508
|
return Struct(pick3(fields, ...keys5));
|
|
19500
19509
|
}
|
|
19501
19510
|
static omit(...keys5) {
|
|
19502
19511
|
return Struct(omit3(fields, ...keys5));
|
|
19503
19512
|
}
|
|
19504
|
-
}
|
|
19505
|
-
...fields
|
|
19506
|
-
}), __publicField(_a47, "records", [...records]), __publicField(_a47, "make", (props, options) => {
|
|
19507
|
-
const propsWithDefaults = lazilyMergeDefaults(fields, {
|
|
19508
|
-
...props
|
|
19509
|
-
});
|
|
19510
|
-
return getDisableValidationMakeOption(options) ? propsWithDefaults : validateSync(_a47)(propsWithDefaults);
|
|
19511
|
-
}), _a47;
|
|
19513
|
+
};
|
|
19512
19514
|
};
|
|
19513
19515
|
function Struct(fields, ...records) {
|
|
19514
19516
|
return makeTypeLiteralClass(fields, records);
|
|
@@ -19518,16 +19520,15 @@ var TaggedStruct = (value3, fields) => Struct({
|
|
|
19518
19520
|
_tag: tag(value3),
|
|
19519
19521
|
...fields
|
|
19520
19522
|
});
|
|
19521
|
-
var makeRecordClass = (key, value3, ast) => {
|
|
19522
|
-
|
|
19523
|
-
|
|
19524
|
-
|
|
19525
|
-
|
|
19526
|
-
|
|
19527
|
-
|
|
19528
|
-
|
|
19529
|
-
|
|
19530
|
-
}, __publicField(_a47, "key", key), __publicField(_a47, "value", value3), _a47;
|
|
19523
|
+
var makeRecordClass = (key, value3, ast) => class RecordClass extends makeTypeLiteralClass({}, [{
|
|
19524
|
+
key,
|
|
19525
|
+
value: value3
|
|
19526
|
+
}], ast) {
|
|
19527
|
+
static annotations(annotations3) {
|
|
19528
|
+
return makeRecordClass(key, value3, mergeSchemaAnnotations(this.ast, annotations3));
|
|
19529
|
+
}
|
|
19530
|
+
static key = key;
|
|
19531
|
+
static value = value3;
|
|
19531
19532
|
};
|
|
19532
19533
|
var Record = (options) => makeRecordClass(options.key, options.value);
|
|
19533
19534
|
var pick4 = (...keys5) => (self) => make34(pick(self.ast, keys5));
|
|
@@ -19543,15 +19544,13 @@ var pluck = /* @__PURE__ */ dual(2, (schema, key) => {
|
|
|
19543
19544
|
}
|
|
19544
19545
|
});
|
|
19545
19546
|
});
|
|
19546
|
-
var makeBrandClass = (ast) => {
|
|
19547
|
-
|
|
19548
|
-
|
|
19549
|
-
|
|
19550
|
-
|
|
19551
|
-
|
|
19552
|
-
}
|
|
19553
|
-
return getDisableValidationMakeOption(options) ? a : validateSync(_a47)(a);
|
|
19554
|
-
}), _a47;
|
|
19547
|
+
var makeBrandClass = (ast) => class BrandClass extends make34(ast) {
|
|
19548
|
+
static annotations(annotations3) {
|
|
19549
|
+
return makeBrandClass(mergeSchemaAnnotations(this.ast, annotations3));
|
|
19550
|
+
}
|
|
19551
|
+
static make = (a, options) => {
|
|
19552
|
+
return getDisableValidationMakeOption(options) ? a : validateSync(this)(a);
|
|
19553
|
+
};
|
|
19555
19554
|
};
|
|
19556
19555
|
var brand = (brand2, annotations3) => (self) => {
|
|
19557
19556
|
const annotation = match2(getBrandAnnotation(self.ast), {
|
|
@@ -19690,15 +19689,16 @@ var extend2 = /* @__PURE__ */ dual(2, (self, that) => make34(extendAST(self.ast,
|
|
|
19690
19689
|
var compose2 = /* @__PURE__ */ dual((args2) => isSchema(args2[1]), (from, to) => make34(compose(from.ast, to.ast)));
|
|
19691
19690
|
var suspend5 = (f) => make34(new Suspend(() => f().ast));
|
|
19692
19691
|
var RefineSchemaId = /* @__PURE__ */ Symbol.for("effect/SchemaId/Refine");
|
|
19693
|
-
var makeRefineClass = (from, filter8, ast) => {
|
|
19694
|
-
|
|
19695
|
-
|
|
19696
|
-
|
|
19697
|
-
|
|
19698
|
-
|
|
19699
|
-
|
|
19700
|
-
|
|
19701
|
-
|
|
19692
|
+
var makeRefineClass = (from, filter8, ast) => class RefineClass extends make34(ast) {
|
|
19693
|
+
static annotations(annotations3) {
|
|
19694
|
+
return makeRefineClass(this.from, this.filter, mergeSchemaAnnotations(this.ast, annotations3));
|
|
19695
|
+
}
|
|
19696
|
+
static [RefineSchemaId] = from;
|
|
19697
|
+
static from = from;
|
|
19698
|
+
static filter = filter8;
|
|
19699
|
+
static make = (a, options) => {
|
|
19700
|
+
return getDisableValidationMakeOption(options) ? a : validateSync(this)(a);
|
|
19701
|
+
};
|
|
19702
19702
|
};
|
|
19703
19703
|
var fromFilterPredicateReturnTypeItem = (item, ast, input) => {
|
|
19704
19704
|
if (isBoolean(item)) {
|
|
@@ -19745,13 +19745,12 @@ var filterEffect = /* @__PURE__ */ dual(2, (self, f) => transformOrFail(self, ty
|
|
|
19745
19745
|
})),
|
|
19746
19746
|
encode: succeed6
|
|
19747
19747
|
}));
|
|
19748
|
-
var makeTransformationClass = (from, to, ast) => {
|
|
19749
|
-
|
|
19750
|
-
|
|
19751
|
-
|
|
19752
|
-
|
|
19753
|
-
|
|
19754
|
-
}, __publicField(_a47, "from", from), __publicField(_a47, "to", to), _a47;
|
|
19748
|
+
var makeTransformationClass = (from, to, ast) => class TransformationClass extends make34(ast) {
|
|
19749
|
+
static annotations(annotations3) {
|
|
19750
|
+
return makeTransformationClass(this.from, this.to, mergeSchemaAnnotations(this.ast, annotations3));
|
|
19751
|
+
}
|
|
19752
|
+
static from = from;
|
|
19753
|
+
static to = to;
|
|
19755
19754
|
};
|
|
19756
19755
|
var transformOrFail = /* @__PURE__ */ dual((args2) => isSchema(args2[0]) && isSchema(args2[1]), (from, to, options) => makeTransformationClass(from, to, new Transformation(from.ast, to.ast, new FinalTransformation(options.decode, options.encode))));
|
|
19757
19756
|
var transform2 = /* @__PURE__ */ dual((args2) => isSchema(args2[0]) && isSchema(args2[1]), (from, to, options) => transformOrFail(from, to, {
|
|
@@ -21498,14 +21497,13 @@ var Class6 = (identifier2) => (fieldsOr, annotations3) => makeClass({
|
|
|
21498
21497
|
});
|
|
21499
21498
|
var getClassTag = (tag2) => withConstructorDefault(propertySignature(Literal2(tag2)), () => tag2);
|
|
21500
21499
|
var TaggedClass2 = (identifier2) => (tag2, fieldsOr, annotations3) => {
|
|
21501
|
-
var _a47;
|
|
21502
21500
|
const fields = getFieldsFromFieldsOr(fieldsOr);
|
|
21503
21501
|
const schema = getSchemaFromFieldsOr(fieldsOr);
|
|
21504
21502
|
const newFields = {
|
|
21505
21503
|
_tag: getClassTag(tag2)
|
|
21506
21504
|
};
|
|
21507
21505
|
const taggedFields = extendFields(newFields, fields);
|
|
21508
|
-
return
|
|
21506
|
+
return class TaggedClass extends makeClass({
|
|
21509
21507
|
kind: "TaggedClass",
|
|
21510
21508
|
identifier: identifier2 ?? tag2,
|
|
21511
21509
|
schema: extend2(schema, Struct(newFields)),
|
|
@@ -21513,10 +21511,10 @@ var TaggedClass2 = (identifier2) => (tag2, fieldsOr, annotations3) => {
|
|
|
21513
21511
|
Base: Class4,
|
|
21514
21512
|
annotations: annotations3
|
|
21515
21513
|
}) {
|
|
21516
|
-
|
|
21514
|
+
static _tag = tag2;
|
|
21515
|
+
};
|
|
21517
21516
|
};
|
|
21518
21517
|
var TaggedError2 = (identifier2) => (tag2, fieldsOr, annotations3) => {
|
|
21519
|
-
var _a47;
|
|
21520
21518
|
class Base3 extends Error3 {
|
|
21521
21519
|
}
|
|
21522
21520
|
;
|
|
@@ -21527,7 +21525,7 @@ var TaggedError2 = (identifier2) => (tag2, fieldsOr, annotations3) => {
|
|
|
21527
21525
|
_tag: getClassTag(tag2)
|
|
21528
21526
|
};
|
|
21529
21527
|
const taggedFields = extendFields(newFields, fields);
|
|
21530
|
-
return
|
|
21528
|
+
return class TaggedErrorClass extends makeClass({
|
|
21531
21529
|
kind: "TaggedError",
|
|
21532
21530
|
identifier: identifier2 ?? tag2,
|
|
21533
21531
|
schema: extend2(schema, Struct(newFields)),
|
|
@@ -21536,10 +21534,11 @@ var TaggedError2 = (identifier2) => (tag2, fieldsOr, annotations3) => {
|
|
|
21536
21534
|
annotations: annotations3,
|
|
21537
21535
|
disableToString: true
|
|
21538
21536
|
}) {
|
|
21537
|
+
static _tag = tag2;
|
|
21539
21538
|
get message() {
|
|
21540
21539
|
return `{ ${ownKeys(fields).map((p) => `${formatPropertyKey(p)}: ${formatUnknown(this[p])}`).join(", ")} }`;
|
|
21541
21540
|
}
|
|
21542
|
-
}
|
|
21541
|
+
};
|
|
21543
21542
|
};
|
|
21544
21543
|
var extendFields = (a, b) => {
|
|
21545
21544
|
const out = {
|
|
@@ -21575,7 +21574,6 @@ var makeClass = ({
|
|
|
21575
21574
|
kind,
|
|
21576
21575
|
schema
|
|
21577
21576
|
}) => {
|
|
21578
|
-
var _a47, _b14;
|
|
21579
21577
|
const classSymbol = Symbol.for(`effect/Schema/${kind}/${identifier2}`);
|
|
21580
21578
|
const [typeAnnotations, transformationAnnotations, encodedAnnotations] = getClassAnnotations(annotations3);
|
|
21581
21579
|
const typeSchema_ = typeSchema(schema);
|
|
@@ -21602,7 +21600,7 @@ var makeClass = ({
|
|
|
21602
21600
|
...transformationAnnotations
|
|
21603
21601
|
});
|
|
21604
21602
|
const fallbackInstanceOf = (u) => hasProperty(u, classSymbol) && is(typeSide)(u);
|
|
21605
|
-
const klass =
|
|
21603
|
+
const klass = class extends Base3 {
|
|
21606
21604
|
constructor(props = {}, options = false) {
|
|
21607
21605
|
props = {
|
|
21608
21606
|
...props
|
|
@@ -21616,6 +21614,10 @@ var makeClass = ({
|
|
|
21616
21614
|
}
|
|
21617
21615
|
super(props, true);
|
|
21618
21616
|
}
|
|
21617
|
+
// ----------------
|
|
21618
|
+
// Schema interface
|
|
21619
|
+
// ----------------
|
|
21620
|
+
static [TypeId15] = variance5;
|
|
21619
21621
|
static get ast() {
|
|
21620
21622
|
let out = astCache.get(this);
|
|
21621
21623
|
if (out) {
|
|
@@ -21659,6 +21661,10 @@ var makeClass = ({
|
|
|
21659
21661
|
static make(...args2) {
|
|
21660
21662
|
return new this(...args2);
|
|
21661
21663
|
}
|
|
21664
|
+
static fields = {
|
|
21665
|
+
...fields
|
|
21666
|
+
};
|
|
21667
|
+
static identifier = identifier2;
|
|
21662
21668
|
static extend(identifier3) {
|
|
21663
21669
|
return (newFieldsOr, annotations4) => {
|
|
21664
21670
|
const newFields = getFieldsFromFieldsOr(newFieldsOr);
|
|
@@ -21703,15 +21709,10 @@ var makeClass = ({
|
|
|
21703
21709
|
// ----------------
|
|
21704
21710
|
// other
|
|
21705
21711
|
// ----------------
|
|
21706
|
-
get [
|
|
21712
|
+
get [classSymbol]() {
|
|
21707
21713
|
return classSymbol;
|
|
21708
21714
|
}
|
|
21709
|
-
}
|
|
21710
|
-
// Schema interface
|
|
21711
|
-
// ----------------
|
|
21712
|
-
__publicField(_b14, _a47, variance5), __publicField(_b14, "fields", {
|
|
21713
|
-
...fields
|
|
21714
|
-
}), __publicField(_b14, "identifier", identifier2), _b14);
|
|
21715
|
+
};
|
|
21715
21716
|
if (disableToString !== true) {
|
|
21716
21717
|
Object.defineProperty(klass.prototype, "toString", {
|
|
21717
21718
|
value() {
|
|
@@ -21977,14 +21978,14 @@ var Defect = /* @__PURE__ */ transform2(Unknown, Unknown, {
|
|
|
21977
21978
|
strict: true,
|
|
21978
21979
|
decode: (u) => {
|
|
21979
21980
|
if (isObject(u) && "message" in u && typeof u.message === "string") {
|
|
21980
|
-
const
|
|
21981
|
+
const err2 = new Error(u.message, {
|
|
21981
21982
|
cause: u
|
|
21982
21983
|
});
|
|
21983
21984
|
if ("name" in u && typeof u.name === "string") {
|
|
21984
|
-
|
|
21985
|
+
err2.name = u.name;
|
|
21985
21986
|
}
|
|
21986
|
-
|
|
21987
|
-
return
|
|
21987
|
+
err2.stack = "stack" in u && typeof u.stack === "string" ? u.stack : "";
|
|
21988
|
+
return err2;
|
|
21988
21989
|
}
|
|
21989
21990
|
return String(u);
|
|
21990
21991
|
},
|
|
@@ -22255,11 +22256,10 @@ var serializeExit = /* @__PURE__ */ dual(2, (self, value3) => encode4(exitSchema
|
|
|
22255
22256
|
var deserializeExit = /* @__PURE__ */ dual(2, (self, value3) => decodeUnknown2(exitSchema(self))(value3));
|
|
22256
22257
|
var asSerializableWithResult = (procedure) => procedure;
|
|
22257
22258
|
var TaggedRequest = (identifier2) => (tag2, options, annotations3) => {
|
|
22258
|
-
var _a47;
|
|
22259
22259
|
const taggedFields = extendFields({
|
|
22260
22260
|
_tag: getClassTag(tag2)
|
|
22261
22261
|
}, options.payload);
|
|
22262
|
-
return
|
|
22262
|
+
return class TaggedRequestClass extends makeClass({
|
|
22263
22263
|
kind: "TaggedRequest",
|
|
22264
22264
|
identifier: identifier2 ?? tag2,
|
|
22265
22265
|
schema: Struct(taggedFields),
|
|
@@ -22267,6 +22267,9 @@ var TaggedRequest = (identifier2) => (tag2, options, annotations3) => {
|
|
|
22267
22267
|
Base: Class5,
|
|
22268
22268
|
annotations: annotations3
|
|
22269
22269
|
}) {
|
|
22270
|
+
static _tag = tag2;
|
|
22271
|
+
static success = options.success;
|
|
22272
|
+
static failure = options.failure;
|
|
22270
22273
|
get [symbolSerializable]() {
|
|
22271
22274
|
return this.constructor;
|
|
22272
22275
|
}
|
|
@@ -22276,7 +22279,7 @@ var TaggedRequest = (identifier2) => (tag2, options, annotations3) => {
|
|
|
22276
22279
|
success: options.success
|
|
22277
22280
|
};
|
|
22278
22281
|
}
|
|
22279
|
-
}
|
|
22282
|
+
};
|
|
22280
22283
|
};
|
|
22281
22284
|
var equivalence2 = (schema) => go2(schema.ast, []);
|
|
22282
22285
|
var getEquivalenceAnnotation = /* @__PURE__ */ getAnnotation(EquivalenceAnnotationId);
|
|
@@ -22470,9 +22473,10 @@ function defaultConfig() {
|
|
|
22470
22473
|
var debug = Debug("prisma:config:defineConfig");
|
|
22471
22474
|
function defineConfig(configInput) {
|
|
22472
22475
|
const config2 = defaultConfig();
|
|
22473
|
-
debug("
|
|
22476
|
+
debug("[default]: %o", config2);
|
|
22474
22477
|
defineSchemaConfig(config2, configInput);
|
|
22475
22478
|
defineStudioConfig(config2, configInput);
|
|
22479
|
+
defineMigrateConfig(config2, configInput);
|
|
22476
22480
|
return config2;
|
|
22477
22481
|
}
|
|
22478
22482
|
function defineSchemaConfig(config2, configInput) {
|
|
@@ -22480,54 +22484,80 @@ function defineSchemaConfig(config2, configInput) {
|
|
|
22480
22484
|
return;
|
|
22481
22485
|
}
|
|
22482
22486
|
config2.schema = configInput.schema;
|
|
22483
|
-
debug("
|
|
22487
|
+
debug("[config.schema]: %o", config2.schema);
|
|
22484
22488
|
}
|
|
22485
22489
|
function defineStudioConfig(config2, configInput) {
|
|
22486
22490
|
if (!configInput.studio) {
|
|
22487
22491
|
return;
|
|
22488
22492
|
}
|
|
22493
|
+
const { adapter: getAdapterFactory } = configInput.studio;
|
|
22489
22494
|
config2.studio = {
|
|
22490
|
-
adapter:
|
|
22495
|
+
adapter: async (env) => {
|
|
22496
|
+
const adapterFactory = await getAdapterFactory(env);
|
|
22497
|
+
debug("[config.studio.adapter]: %o", adapterFactory.adapterName);
|
|
22498
|
+
return adapterFactory;
|
|
22499
|
+
}
|
|
22491
22500
|
};
|
|
22492
|
-
debug("
|
|
22501
|
+
debug("[config.studio]: %o", config2.studio);
|
|
22502
|
+
}
|
|
22503
|
+
function defineMigrateConfig(config2, configInput) {
|
|
22504
|
+
if (!configInput.migrate) {
|
|
22505
|
+
return;
|
|
22506
|
+
}
|
|
22507
|
+
const { adapter: getAdapterFactory } = configInput.migrate;
|
|
22508
|
+
config2.migrate = {
|
|
22509
|
+
adapter: async (env) => {
|
|
22510
|
+
const adapterFactory = await getAdapterFactory(env);
|
|
22511
|
+
debug("[config.migrate.adapter]: %o", adapterFactory.adapterName);
|
|
22512
|
+
return bindMigrationAwareSqlAdapterFactory(adapterFactory);
|
|
22513
|
+
}
|
|
22514
|
+
};
|
|
22515
|
+
debug("[config.schema]: %o", config2.migrate);
|
|
22493
22516
|
}
|
|
22494
22517
|
|
|
22495
22518
|
// src/PrismaConfig.ts
|
|
22496
22519
|
var debug2 = Debug("prisma:config:PrismaConfig");
|
|
22497
|
-
var
|
|
22520
|
+
var sqlMigrationAwareDriverAdapterFactoryShape = () => Schema_exports.declare(
|
|
22498
22521
|
(input) => {
|
|
22499
22522
|
return input instanceof Function;
|
|
22500
22523
|
},
|
|
22501
22524
|
{
|
|
22502
|
-
identifier: "
|
|
22525
|
+
identifier: "SqlMigrationAwareDriverAdapterFactory<Env>",
|
|
22503
22526
|
encode: identity,
|
|
22504
22527
|
decode: identity
|
|
22505
22528
|
}
|
|
22506
22529
|
);
|
|
22507
|
-
var
|
|
22530
|
+
var errorCapturingSqlMigrationAwareDriverAdapterFactoryShape = () => Schema_exports.declare(
|
|
22531
|
+
(input) => {
|
|
22532
|
+
return input instanceof Function;
|
|
22533
|
+
},
|
|
22534
|
+
{
|
|
22535
|
+
identifier: "ErrorCapturingSqlMigrationAwareDriverAdapterFactory<Env>",
|
|
22536
|
+
encode: identity,
|
|
22537
|
+
decode: identity
|
|
22538
|
+
}
|
|
22539
|
+
);
|
|
22540
|
+
var createPrismaStudioConfigShape = () => Schema_exports.Struct({
|
|
22508
22541
|
/**
|
|
22509
22542
|
* Instantiates the Prisma driver adapter to use for Prisma Studio.
|
|
22510
22543
|
*/
|
|
22511
|
-
adapter:
|
|
22512
|
-
});
|
|
22513
|
-
var PrismaConfigSchemaSingleShape = Schema_exports.Struct({
|
|
22514
|
-
kind: Schema_exports.Literal("single"),
|
|
22515
|
-
filePath: Schema_exports.String
|
|
22544
|
+
adapter: sqlMigrationAwareDriverAdapterFactoryShape()
|
|
22516
22545
|
});
|
|
22517
|
-
var
|
|
22518
|
-
|
|
22519
|
-
|
|
22546
|
+
var createPrismaMigrateConfigInternalShape = () => Schema_exports.Struct({
|
|
22547
|
+
/**
|
|
22548
|
+
* Instantiates the Prisma driver adapter to use for Prisma Migrate + Introspect.
|
|
22549
|
+
*/
|
|
22550
|
+
adapter: errorCapturingSqlMigrationAwareDriverAdapterFactoryShape()
|
|
22520
22551
|
});
|
|
22521
|
-
var PrismaSchemaConfigShape = Schema_exports.Union(PrismaConfigSchemaSingleShape, PrismaConfigSchemaMultiShape);
|
|
22522
22552
|
if (false) {
|
|
22523
|
-
__testPrismaSchemaConfigShapeValueA;
|
|
22524
|
-
__testPrismaSchemaConfigShapeValueB;
|
|
22525
22553
|
__testPrismaStudioConfigShapeValueA;
|
|
22526
22554
|
__testPrismaStudioConfigShapeValueB;
|
|
22555
|
+
__testPrismaMigrateConfigShapeValueA;
|
|
22556
|
+
__testPrismaMigrateConfigShapeValueB;
|
|
22527
22557
|
}
|
|
22528
22558
|
var createPrismaConfigShape = () => Schema_exports.Struct({
|
|
22529
22559
|
earlyAccess: Schema_exports.Literal(true),
|
|
22530
|
-
schema: Schema_exports.optional(
|
|
22560
|
+
schema: Schema_exports.optional(Schema_exports.String)
|
|
22531
22561
|
});
|
|
22532
22562
|
if (false) {
|
|
22533
22563
|
__testPrismaConfigValueA;
|
|
@@ -22541,8 +22571,9 @@ function parsePrismaConfigShape(input) {
|
|
|
22541
22571
|
var PRISMA_CONFIG_INTERNAL_BRAND = Symbol.for("PrismaConfigInternal");
|
|
22542
22572
|
var createPrismaConfigInternalShape = () => Schema_exports.Struct({
|
|
22543
22573
|
earlyAccess: Schema_exports.Literal(true),
|
|
22544
|
-
schema: Schema_exports.optional(
|
|
22545
|
-
studio: Schema_exports.optional(
|
|
22574
|
+
schema: Schema_exports.optional(Schema_exports.String),
|
|
22575
|
+
studio: Schema_exports.optional(createPrismaStudioConfigShape()),
|
|
22576
|
+
migrate: Schema_exports.optional(createPrismaMigrateConfigInternalShape()),
|
|
22546
22577
|
loadedFromFile: Schema_exports.NullOr(Schema_exports.String)
|
|
22547
22578
|
});
|
|
22548
22579
|
if (false) {
|
|
@@ -22698,21 +22729,10 @@ async function requireTypeScriptFile(resolvedPath) {
|
|
|
22698
22729
|
}
|
|
22699
22730
|
}
|
|
22700
22731
|
function transformPathsInConfigToAbsolute(prismaConfig, resolvedPath) {
|
|
22701
|
-
if (prismaConfig.schema
|
|
22732
|
+
if (prismaConfig.schema) {
|
|
22702
22733
|
return {
|
|
22703
22734
|
...prismaConfig,
|
|
22704
|
-
schema:
|
|
22705
|
-
...prismaConfig.schema,
|
|
22706
|
-
filePath: import_node_path.default.resolve(import_node_path.default.dirname(resolvedPath), prismaConfig.schema.filePath)
|
|
22707
|
-
}
|
|
22708
|
-
};
|
|
22709
|
-
} else if (prismaConfig.schema?.kind === "multi") {
|
|
22710
|
-
return {
|
|
22711
|
-
...prismaConfig,
|
|
22712
|
-
schema: {
|
|
22713
|
-
...prismaConfig.schema,
|
|
22714
|
-
folderPath: import_node_path.default.resolve(import_node_path.default.dirname(resolvedPath), prismaConfig.schema.folderPath)
|
|
22715
|
-
}
|
|
22735
|
+
schema: import_node_path.default.resolve(import_node_path.default.dirname(resolvedPath), prismaConfig.schema)
|
|
22716
22736
|
};
|
|
22717
22737
|
} else {
|
|
22718
22738
|
return prismaConfig;
|