@dxos/errors 0.8.4-main.406dc2a → 0.8.4-main.59c2e9b

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