@dxos/errors 0.8.4-main.72ec0f3 → 0.8.4-main.765dc60934

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.
Files changed (16) hide show
  1. package/LICENSE +102 -5
  2. package/dist/lib/browser/index.mjs +23 -19
  3. package/dist/lib/browser/index.mjs.map +3 -3
  4. package/dist/lib/browser/meta.json +1 -1
  5. package/dist/lib/node-esm/index.mjs +23 -19
  6. package/dist/lib/node-esm/index.mjs.map +3 -3
  7. package/dist/lib/node-esm/meta.json +1 -1
  8. package/dist/types/src/base.d.ts +18 -21
  9. package/dist/types/src/base.d.ts.map +1 -1
  10. package/dist/types/src/errors.d.ts +193 -162
  11. package/dist/types/src/errors.d.ts.map +1 -1
  12. package/dist/types/tsconfig.tsbuildinfo +1 -1
  13. package/package.json +7 -6
  14. package/src/base.ts +19 -17
  15. package/src/errors.test.ts +12 -11
  16. package/src/errors.ts +8 -6
package/dist/types/src/errors.d.ts CHANGED
@@ -1,57 +1,53 @@
1
1
  import { BaseError } from './base';
2
2
  declare const ApiError_base: {
3
3
  new (options?: import("./base").BaseErrorOptions): {
4
- code: "API";
4
+ cause?: unknown;
5
+ stack?: string;
6
+ name: "ApiError";
5
7
  context: Record<string, unknown>;
6
- get name(): "API";
7
8
  get message(): string;
8
- get _tag(): "API";
9
- stack?: string;
10
- cause?: unknown;
9
+ get _tag(): "ApiError";
11
10
  };
12
- code: "API";
13
- is(error: unknown): error is BaseError;
11
+ isError(error: unknown): error is Error;
12
+ name: "ApiError";
13
+ is(error: unknown): boolean;
14
14
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
15
15
  ifTypeDiffers?: boolean;
16
16
  }) | undefined): (error: unknown) => {
17
- code: "API";
17
+ cause?: unknown;
18
+ stack?: string;
19
+ name: "ApiError";
18
20
  context: Record<string, unknown>;
19
- get name(): "API";
20
21
  get message(): string;
21
- get _tag(): "API";
22
- stack?: string;
23
- cause?: unknown;
22
+ get _tag(): "ApiError";
24
23
  };
25
- extend<Code extends string = string>(code: Code, message?: string): {
24
+ extend<Name extends string = string>(name: Name, message?: string): {
26
25
  new (options?: import("./base").BaseErrorOptions): {
27
- code: Code;
26
+ cause?: unknown;
27
+ stack?: string;
28
+ name: Name;
28
29
  context: Record<string, unknown>;
29
- get name(): Code;
30
30
  get message(): string;
31
- get _tag(): Code;
32
- stack?: string;
33
- cause?: unknown;
31
+ get _tag(): Name;
34
32
  };
35
- code: Code;
33
+ isError(error: unknown): error is Error;
34
+ name: Name;
36
35
  is(error: unknown): error is BaseError;
37
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
36
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
38
37
  ifTypeDiffers?: boolean;
39
38
  }): (error: unknown) => {
40
- code: Code;
39
+ cause?: unknown;
40
+ stack?: string;
41
+ name: Name;
41
42
  context: Record<string, unknown>;
42
- get name(): Code;
43
43
  get message(): string;
44
- get _tag(): Code;
45
- stack?: string;
46
- cause?: unknown;
44
+ get _tag(): Name;
47
45
  };
48
- extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
49
- isError(error: unknown): error is Error;
46
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
50
47
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
51
48
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
52
49
  stackTraceLimit: number;
53
50
  };
54
- isError(error: unknown): error is Error;
55
51
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
56
52
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
57
53
  stackTraceLimit: number;
@@ -60,57 +56,53 @@ export declare class ApiError extends ApiError_base {
60
56
  }
61
57
  declare const SystemError_base: {
62
58
  new (options?: import("./base").BaseErrorOptions): {
63
- code: "SYSTEM";
59
+ cause?: unknown;
60
+ stack?: string;
61
+ name: "SystemError";
64
62
  context: Record<string, unknown>;
65
- get name(): "SYSTEM";
66
63
  get message(): string;
67
- get _tag(): "SYSTEM";
68
- stack?: string;
69
- cause?: unknown;
64
+ get _tag(): "SystemError";
70
65
  };
71
- code: "SYSTEM";
66
+ isError(error: unknown): error is Error;
67
+ name: "SystemError";
72
68
  is(error: unknown): error is BaseError;
73
69
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
74
70
  ifTypeDiffers?: boolean;
75
71
  }) | undefined): (error: unknown) => {
76
- code: "SYSTEM";
72
+ cause?: unknown;
73
+ stack?: string;
74
+ name: "SystemError";
77
75
  context: Record<string, unknown>;
78
- get name(): "SYSTEM";
79
76
  get message(): string;
80
- get _tag(): "SYSTEM";
81
- stack?: string;
82
- cause?: unknown;
77
+ get _tag(): "SystemError";
83
78
  };
84
- extend<Code extends string = string>(code: Code, message?: string): {
79
+ extend<Name extends string = string>(name: Name, message?: string): {
85
80
  new (options?: import("./base").BaseErrorOptions): {
86
- code: Code;
81
+ cause?: unknown;
82
+ stack?: string;
83
+ name: Name;
87
84
  context: Record<string, unknown>;
88
- get name(): Code;
89
85
  get message(): string;
90
- get _tag(): Code;
91
- stack?: string;
92
- cause?: unknown;
86
+ get _tag(): Name;
93
87
  };
94
- code: Code;
88
+ isError(error: unknown): error is Error;
89
+ name: Name;
95
90
  is(error: unknown): error is BaseError;
96
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
91
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
97
92
  ifTypeDiffers?: boolean;
98
93
  }): (error: unknown) => {
99
- code: Code;
94
+ cause?: unknown;
95
+ stack?: string;
96
+ name: Name;
100
97
  context: Record<string, unknown>;
101
- get name(): Code;
102
98
  get message(): string;
103
- get _tag(): Code;
104
- stack?: string;
105
- cause?: unknown;
99
+ get _tag(): Name;
106
100
  };
107
- extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
108
- isError(error: unknown): error is Error;
101
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
109
102
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
110
103
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
111
104
  stackTraceLimit: number;
112
105
  };
113
- isError(error: unknown): error is Error;
114
106
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
115
107
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
116
108
  stackTraceLimit: number;
@@ -119,57 +111,53 @@ export declare class SystemError extends SystemError_base {
119
111
  }
120
112
  declare const InternalError_base: {
121
113
  new (options?: import("./base").BaseErrorOptions): {
122
- code: "INTERNAL";
114
+ cause?: unknown;
115
+ stack?: string;
116
+ name: "InternalError";
123
117
  context: Record<string, unknown>;
124
- get name(): "INTERNAL";
125
118
  get message(): string;
126
- get _tag(): "INTERNAL";
127
- stack?: string;
128
- cause?: unknown;
119
+ get _tag(): "InternalError";
129
120
  };
130
- code: "INTERNAL";
121
+ isError(error: unknown): error is Error;
122
+ name: "InternalError";
131
123
  is(error: unknown): error is BaseError;
132
124
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
133
125
  ifTypeDiffers?: boolean;
134
126
  }) | undefined): (error: unknown) => {
135
- code: "INTERNAL";
127
+ cause?: unknown;
128
+ stack?: string;
129
+ name: "InternalError";
136
130
  context: Record<string, unknown>;
137
- get name(): "INTERNAL";
138
131
  get message(): string;
139
- get _tag(): "INTERNAL";
140
- stack?: string;
141
- cause?: unknown;
132
+ get _tag(): "InternalError";
142
133
  };
143
- extend<Code extends string = string>(code: Code, message?: string): {
134
+ extend<Name extends string = string>(name: Name, message?: string): {
144
135
  new (options?: import("./base").BaseErrorOptions): {
145
- code: Code;
136
+ cause?: unknown;
137
+ stack?: string;
138
+ name: Name;
146
139
  context: Record<string, unknown>;
147
- get name(): Code;
148
140
  get message(): string;
149
- get _tag(): Code;
150
- stack?: string;
151
- cause?: unknown;
141
+ get _tag(): Name;
152
142
  };
153
- code: Code;
143
+ isError(error: unknown): error is Error;
144
+ name: Name;
154
145
  is(error: unknown): error is BaseError;
155
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
146
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
156
147
  ifTypeDiffers?: boolean;
157
148
  }): (error: unknown) => {
158
- code: Code;
149
+ cause?: unknown;
150
+ stack?: string;
151
+ name: Name;
159
152
  context: Record<string, unknown>;
160
- get name(): Code;
161
153
  get message(): string;
162
- get _tag(): Code;
163
- stack?: string;
164
- cause?: unknown;
154
+ get _tag(): Name;
165
155
  };
166
- extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
167
- isError(error: unknown): error is Error;
156
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
168
157
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
169
158
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
170
159
  stackTraceLimit: number;
171
160
  };
172
- isError(error: unknown): error is Error;
173
161
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
174
162
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
175
163
  stackTraceLimit: number;
@@ -178,57 +166,53 @@ export declare class InternalError extends InternalError_base {
178
166
  }
179
167
  declare const TimeoutError_base: {
180
168
  new (options?: import("./base").BaseErrorOptions): {
181
- code: "TIMEOUT";
169
+ cause?: unknown;
170
+ stack?: string;
171
+ name: "TimeoutError";
182
172
  context: Record<string, unknown>;
183
- get name(): "TIMEOUT";
184
173
  get message(): string;
185
- get _tag(): "TIMEOUT";
186
- stack?: string;
187
- cause?: unknown;
174
+ get _tag(): "TimeoutError";
188
175
  };
189
- code: "TIMEOUT";
176
+ isError(error: unknown): error is Error;
177
+ name: "TimeoutError";
190
178
  is(error: unknown): error is BaseError;
191
179
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
192
180
  ifTypeDiffers?: boolean;
193
181
  }) | undefined): (error: unknown) => {
194
- code: "TIMEOUT";
182
+ cause?: unknown;
183
+ stack?: string;
184
+ name: "TimeoutError";
195
185
  context: Record<string, unknown>;
196
- get name(): "TIMEOUT";
197
186
  get message(): string;
198
- get _tag(): "TIMEOUT";
199
- stack?: string;
200
- cause?: unknown;
187
+ get _tag(): "TimeoutError";
201
188
  };
202
- extend<Code extends string = string>(code: Code, message?: string): {
189
+ extend<Name extends string = string>(name: Name, message?: string): {
203
190
  new (options?: import("./base").BaseErrorOptions): {
204
- code: Code;
191
+ cause?: unknown;
192
+ stack?: string;
193
+ name: Name;
205
194
  context: Record<string, unknown>;
206
- get name(): Code;
207
195
  get message(): string;
208
- get _tag(): Code;
209
- stack?: string;
210
- cause?: unknown;
196
+ get _tag(): Name;
211
197
  };
212
- code: Code;
198
+ isError(error: unknown): error is Error;
199
+ name: Name;
213
200
  is(error: unknown): error is BaseError;
214
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
201
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
215
202
  ifTypeDiffers?: boolean;
216
203
  }): (error: unknown) => {
217
- code: Code;
204
+ cause?: unknown;
205
+ stack?: string;
206
+ name: Name;
218
207
  context: Record<string, unknown>;
219
- get name(): Code;
220
208
  get message(): string;
221
- get _tag(): Code;
222
- stack?: string;
223
- cause?: unknown;
209
+ get _tag(): Name;
224
210
  };
225
- extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
226
- isError(error: unknown): error is Error;
211
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
227
212
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
228
213
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
229
214
  stackTraceLimit: number;
230
215
  };
231
- isError(error: unknown): error is Error;
232
216
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
233
217
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
234
218
  stackTraceLimit: number;
@@ -237,57 +221,53 @@ export declare class TimeoutError extends TimeoutError_base {
237
221
  }
238
222
  declare const AbortedError_base: {
239
223
  new (options?: import("./base").BaseErrorOptions): {
240
- code: "ABORTED";
224
+ cause?: unknown;
225
+ stack?: string;
226
+ name: "AbortedError";
241
227
  context: Record<string, unknown>;
242
- get name(): "ABORTED";
243
228
  get message(): string;
244
- get _tag(): "ABORTED";
245
- stack?: string;
246
- cause?: unknown;
229
+ get _tag(): "AbortedError";
247
230
  };
248
- code: "ABORTED";
231
+ isError(error: unknown): error is Error;
232
+ name: "AbortedError";
249
233
  is(error: unknown): error is BaseError;
250
234
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
251
235
  ifTypeDiffers?: boolean;
252
236
  }) | undefined): (error: unknown) => {
253
- code: "ABORTED";
237
+ cause?: unknown;
238
+ stack?: string;
239
+ name: "AbortedError";
254
240
  context: Record<string, unknown>;
255
- get name(): "ABORTED";
256
241
  get message(): string;
257
- get _tag(): "ABORTED";
258
- stack?: string;
259
- cause?: unknown;
242
+ get _tag(): "AbortedError";
260
243
  };
261
- extend<Code extends string = string>(code: Code, message?: string): {
244
+ extend<Name extends string = string>(name: Name, message?: string): {
262
245
  new (options?: import("./base").BaseErrorOptions): {
263
- code: Code;
246
+ cause?: unknown;
247
+ stack?: string;
248
+ name: Name;
264
249
  context: Record<string, unknown>;
265
- get name(): Code;
266
250
  get message(): string;
267
- get _tag(): Code;
268
- stack?: string;
269
- cause?: unknown;
251
+ get _tag(): Name;
270
252
  };
271
- code: Code;
253
+ isError(error: unknown): error is Error;
254
+ name: Name;
272
255
  is(error: unknown): error is BaseError;
273
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
256
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
274
257
  ifTypeDiffers?: boolean;
275
258
  }): (error: unknown) => {
276
- code: Code;
259
+ cause?: unknown;
260
+ stack?: string;
261
+ name: Name;
277
262
  context: Record<string, unknown>;
278
- get name(): Code;
279
263
  get message(): string;
280
- get _tag(): Code;
281
- stack?: string;
282
- cause?: unknown;
264
+ get _tag(): Name;
283
265
  };
284
- extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
285
- isError(error: unknown): error is Error;
266
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
286
267
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
287
268
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
288
269
  stackTraceLimit: number;
289
270
  };
290
- isError(error: unknown): error is Error;
291
271
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
292
272
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
293
273
  stackTraceLimit: number;
@@ -296,62 +276,113 @@ export declare class AbortedError extends AbortedError_base {
296
276
  }
297
277
  declare const NotImplementedError_base: {
298
278
  new (options?: import("./base").BaseErrorOptions): {
299
- code: "NOT_IMPLEMENTED";
279
+ cause?: unknown;
280
+ stack?: string;
281
+ name: "NotImplementedError";
300
282
  context: Record<string, unknown>;
301
- get name(): "NOT_IMPLEMENTED";
302
283
  get message(): string;
303
- get _tag(): "NOT_IMPLEMENTED";
304
- stack?: string;
305
- cause?: unknown;
284
+ get _tag(): "NotImplementedError";
306
285
  };
307
- code: "NOT_IMPLEMENTED";
286
+ isError(error: unknown): error is Error;
287
+ name: "NotImplementedError";
308
288
  is(error: unknown): error is BaseError;
309
289
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
310
290
  ifTypeDiffers?: boolean;
311
291
  }) | undefined): (error: unknown) => {
312
- code: "NOT_IMPLEMENTED";
292
+ cause?: unknown;
293
+ stack?: string;
294
+ name: "NotImplementedError";
313
295
  context: Record<string, unknown>;
314
- get name(): "NOT_IMPLEMENTED";
315
296
  get message(): string;
316
- get _tag(): "NOT_IMPLEMENTED";
317
- stack?: string;
318
- cause?: unknown;
297
+ get _tag(): "NotImplementedError";
319
298
  };
320
- extend<Code extends string = string>(code: Code, message?: string): {
299
+ extend<Name extends string = string>(name: Name, message?: string): {
321
300
  new (options?: import("./base").BaseErrorOptions): {
322
- code: Code;
301
+ cause?: unknown;
302
+ stack?: string;
303
+ name: Name;
323
304
  context: Record<string, unknown>;
324
- get name(): Code;
325
305
  get message(): string;
326
- get _tag(): Code;
327
- stack?: string;
328
- cause?: unknown;
306
+ get _tag(): Name;
329
307
  };
330
- code: Code;
308
+ isError(error: unknown): error is Error;
309
+ name: Name;
331
310
  is(error: unknown): error is BaseError;
332
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
311
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
333
312
  ifTypeDiffers?: boolean;
334
313
  }): (error: unknown) => {
335
- code: Code;
314
+ cause?: unknown;
315
+ stack?: string;
316
+ name: Name;
336
317
  context: Record<string, unknown>;
337
- get name(): Code;
338
318
  get message(): string;
339
- get _tag(): Code;
340
- stack?: string;
319
+ get _tag(): Name;
320
+ };
321
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
322
+ captureStackTrace(targetObject: object, constructorOpt?: Function): void;
323
+ prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
324
+ stackTraceLimit: number;
325
+ };
326
+ captureStackTrace(targetObject: object, constructorOpt?: Function): void;
327
+ prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
328
+ stackTraceLimit: number;
329
+ };
330
+ export declare class NotImplementedError extends NotImplementedError_base {
331
+ }
332
+ declare const RuntimeServiceError_base: {
333
+ new (options?: import("./base").BaseErrorOptions): {
334
+ cause?: unknown;
335
+ stack?: string;
336
+ name: "RuntimeServiceError";
337
+ context: Record<string, unknown>;
338
+ get message(): string;
339
+ get _tag(): "RuntimeServiceError";
340
+ };
341
+ isError(error: unknown): error is Error;
342
+ name: "RuntimeServiceError";
343
+ is(error: unknown): error is BaseError;
344
+ wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
345
+ ifTypeDiffers?: boolean;
346
+ }) | undefined): (error: unknown) => {
347
+ cause?: unknown;
348
+ stack?: string;
349
+ name: "RuntimeServiceError";
350
+ context: Record<string, unknown>;
351
+ get message(): string;
352
+ get _tag(): "RuntimeServiceError";
353
+ };
354
+ extend<Name extends string = string>(name: Name, message?: string): {
355
+ new (options?: import("./base").BaseErrorOptions): {
341
356
  cause?: unknown;
357
+ stack?: string;
358
+ name: Name;
359
+ context: Record<string, unknown>;
360
+ get message(): string;
361
+ get _tag(): Name;
342
362
  };
343
- extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
344
363
  isError(error: unknown): error is Error;
364
+ name: Name;
365
+ is(error: unknown): error is BaseError;
366
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
367
+ ifTypeDiffers?: boolean;
368
+ }): (error: unknown) => {
369
+ cause?: unknown;
370
+ stack?: string;
371
+ name: Name;
372
+ context: Record<string, unknown>;
373
+ get message(): string;
374
+ get _tag(): Name;
375
+ };
376
+ extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
345
377
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
346
378
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
347
379
  stackTraceLimit: number;
348
380
  };
349
- isError(error: unknown): error is Error;
350
381
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
351
382
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
352
383
  stackTraceLimit: number;
353
384
  };
354
- export declare class NotImplementedError extends NotImplementedError_base {
385
+ export declare class RuntimeServiceError extends RuntimeServiceError_base {
355
386
  }
356
387
  export {};
357
388
  //# sourceMappingURL=errors.d.ts.map
package/dist/types/src/errors.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAaua,CAAC;;;;;;;;;;;;;;;;;;;;;AAX3c,qBAAa,QAAS,SAAQ,aAAoC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAWqY,CAAC;;;;;;;;;;;;;;;;;;;;;AAT3c,qBAAa,WAAY,SAAQ,gBAA0C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAS4X,CAAC;;;;;;;;;;;;;;;;;;;;;AAP3c,qBAAa,aAAc,SAAQ,kBAA8C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAOsX,CAAC;;;;;;;;;;;;;;;;;;;;;AAL3c,qBAAa,YAAa,SAAQ,iBAAsC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAK+X,CAAC;;;;;;;;;;;;;;;;;;;;;AAH3c,qBAAa,YAAa,SAAQ,iBAAsC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAG+X,CAAC;;;;;;;;;;;;;;;;;;;;;AAD3c,qBAAa,mBAAoB,SAAQ,wBAAsD;CAAG"}
1
+ {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnC,qBAAa,QAAS,SAAQ,aAAyC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1E,qBAAa,WAAY,SAAQ,gBAA+C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnF,qBAAa,aAAc,SAAQ,kBAAmD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEzF,qBAAa,YAAa,SAAQ,iBAA2C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhF,qBAAa,YAAa,SAAQ,iBAA2C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhF,qBAAa,mBAAoB,SAAQ,wBAA0D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtG,qBAAa,mBAAoB,SAAQ,wBAAgE;CAAG"}