@replit/river 0.10.0 → 0.10.1

package/dist/__tests__/fixtures/services.d.ts

@@ -1,288 +0,0 @@
-import { Observable } from './observable';
-export declare const EchoRequest: import("@sinclair/typebox").TObject<{
-    msg: import("@sinclair/typebox").TString;
-    ignore: import("@sinclair/typebox").TBoolean;
-    end: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-}>;
-export declare const EchoResponse: import("@sinclair/typebox").TObject<{
-    response: import("@sinclair/typebox").TString;
-}>;
-export declare const TestServiceConstructor: () => {
-    name: "test";
-    state: {
-        count: number;
-    };
-    procedures: {
-        add: {
-            input: import("@sinclair/typebox").TObject<{
-                n: import("@sinclair/typebox").TNumber;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                result: import("@sinclair/typebox").TNumber;
-            }>;
-            errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{
-                count: number;
-            }>, input: {
-                n: number;
-            }) => Promise<import("../../router/result").Result<{
-                result: number;
-            }, never>>;
-            type: "rpc";
-        };
-    } & {
-        echo: {
-            input: import("@sinclair/typebox").TObject<{
-                msg: import("@sinclair/typebox").TString;
-                ignore: import("@sinclair/typebox").TBoolean;
-                end: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                response: import("@sinclair/typebox").TString;
-            }>;
-            errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{
-                count: number;
-            }>, input: AsyncIterableIterator<{
-                end?: boolean | undefined;
-                msg: string;
-                ignore: boolean;
-            }>, output: import("it-pushable").Pushable<import("../../router/result").Result<{
-                response: string;
-            }, never>, void, unknown>) => Promise<void>;
-            type: "stream";
-        };
-    } & {
-        echoWithPrefix: {
-            init: import("@sinclair/typebox").TObject<{
-                prefix: import("@sinclair/typebox").TString;
-            }>;
-            input: import("@sinclair/typebox").TObject<{
-                msg: import("@sinclair/typebox").TString;
-                ignore: import("@sinclair/typebox").TBoolean;
-                end: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                response: import("@sinclair/typebox").TString;
-            }>;
-            errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{
-                count: number;
-            }>, init: {
-                prefix: string;
-            }, input: AsyncIterableIterator<{
-                end?: boolean | undefined;
-                msg: string;
-                ignore: boolean;
-            }>, output: import("it-pushable").Pushable<import("../../router/result").Result<{
-                response: string;
-            }, never>, void, unknown>) => Promise<void>;
-            type: "stream";
-        };
-    };
-};
-export declare const OrderingServiceConstructor: () => {
-    name: "test";
-    state: {
-        msgs: number[];
-    };
-    procedures: {
-        add: {
-            input: import("@sinclair/typebox").TObject<{
-                n: import("@sinclair/typebox").TNumber;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                n: import("@sinclair/typebox").TNumber;
-            }>;
-            errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{
-                msgs: number[];
-            }>, input: {
-                n: number;
-            }) => Promise<import("../../router/result").Result<{
-                n: number;
-            }, never>>;
-            type: "rpc";
-        };
-    } & {
-        getAll: {
-            input: import("@sinclair/typebox").TObject<{}>;
-            output: import("@sinclair/typebox").TObject<{
-                msgs: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
-            }>;
-            errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{
-                msgs: number[];
-            }>, input: {}) => Promise<import("../../router/result").Result<{
-                msgs: number[];
-            }, never>>;
-            type: "rpc";
-        };
-    };
-};
-export declare const BinaryFileServiceConstructor: () => {
-    name: "bin";
-    state: {};
-    procedures: {
-        getFile: {
-            input: import("@sinclair/typebox").TObject<{
-                file: import("@sinclair/typebox").TString;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                contents: import("@sinclair/typebox").TUint8Array;
-            }>;
-            errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{}>, input: {
-                file: string;
-            }) => Promise<import("../../router/result").Result<{
-                contents: Uint8Array;
-            }, never>>;
-            type: "rpc";
-        };
-    };
-};
-export declare const DIV_BY_ZERO = "DIV_BY_ZERO";
-export declare const STREAM_ERROR = "STREAM_ERROR";
-export declare const FallibleServiceConstructor: () => {
-    name: "fallible";
-    state: {};
-    procedures: {
-        divide: {
-            input: import("@sinclair/typebox").TObject<{
-                a: import("@sinclair/typebox").TNumber;
-                b: import("@sinclair/typebox").TNumber;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                result: import("@sinclair/typebox").TNumber;
-            }>;
-            errors: import("@sinclair/typebox").TObject<{
-                code: import("@sinclair/typebox").TLiteral<"DIV_BY_ZERO">;
-                message: import("@sinclair/typebox").TString;
-                extras: import("@sinclair/typebox").TObject<{
-                    test: import("@sinclair/typebox").TString;
-                }>;
-            }>;
-            handler: (context: import("../../router").ServiceContextWithState<{}>, input: {
-                a: number;
-                b: number;
-            }) => Promise<import("../../router/result").Result<{
-                result: number;
-            }, {
-                message: string;
-                code: "DIV_BY_ZERO";
-                extras: {
-                    test: string;
-                };
-            }>>;
-            type: "rpc";
-        };
-    } & {
-        echo: {
-            input: import("@sinclair/typebox").TObject<{
-                msg: import("@sinclair/typebox").TString;
-                throwResult: import("@sinclair/typebox").TBoolean;
-                throwError: import("@sinclair/typebox").TBoolean;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                response: import("@sinclair/typebox").TString;
-            }>;
-            errors: import("@sinclair/typebox").TObject<{
-                code: import("@sinclair/typebox").TLiteral<"STREAM_ERROR">;
-                message: import("@sinclair/typebox").TString;
-            }>;
-            handler: (context: import("../../router").ServiceContextWithState<{}>, input: AsyncIterableIterator<{
-                msg: string;
-                throwResult: boolean;
-                throwError: boolean;
-            }>, output: import("it-pushable").Pushable<import("../../router/result").Result<{
-                response: string;
-            }, {
-                message: string;
-                code: "STREAM_ERROR";
-            }>, void, unknown>) => Promise<void>;
-            type: "stream";
-        };
-    };
-};
-export declare const SubscribableServiceConstructor: () => {
-    name: "subscribable";
-    state: {
-        count: Observable<number>;
-    };
-    procedures: {
-        add: {
-            input: import("@sinclair/typebox").TObject<{
-                n: import("@sinclair/typebox").TNumber;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                result: import("@sinclair/typebox").TNumber;
-            }>;
-            errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{
-                count: Observable<number>;
-            }>, input: {
-                n: number;
-            }) => Promise<import("../../router/result").Result<{
-                result: number;
-            }, never>>;
-            type: "rpc";
-        };
-    } & {
-        value: {
-            input: import("@sinclair/typebox").TObject<{}>;
-            output: import("@sinclair/typebox").TObject<{
-                result: import("@sinclair/typebox").TNumber;
-            }>;
-            errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{
-                count: Observable<number>;
-            }>, input: {}, output: import("it-pushable").Pushable<import("../../router/result").Result<{
-                result: number;
-            }, never>, void, unknown>) => Promise<void>;
-            type: "subscription";
-        };
-    };
-};
-export declare const UploadableServiceConstructor: () => {
-    name: "uploadable";
-    state: {};
-    procedures: {
-        addMultiple: {
-            input: import("@sinclair/typebox").TObject<{
-                n: import("@sinclair/typebox").TNumber;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                result: import("@sinclair/typebox").TNumber;
-            }>;
-            errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{}>, input: AsyncIterableIterator<{
-                n: number;
-            }>) => Promise<import("../../router/result").Result<{
-                result: number;
-            }, never>>;
-            type: "upload";
-        };
-    } & {
-        addMultipleWithPrefix: {
-            init: import("@sinclair/typebox").TObject<{
-                prefix: import("@sinclair/typebox").TString;
-            }>;
-            input: import("@sinclair/typebox").TObject<{
-                n: import("@sinclair/typebox").TNumber;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                result: import("@sinclair/typebox").TString;
-            }>;
-            errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{}>, init: {
-                prefix: string;
-            }, input: AsyncIterableIterator<{
-                n: number;
-            }>) => Promise<import("../../router/result").Result<{
-                result: string;
-            }, never>>;
-            type: "upload";
-        };
-    };
-};
-//# sourceMappingURL=services.d.ts.map

package/dist/__tests__/fixtures/services.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../__tests__/fixtures/services.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,WAAW;;;;EAItB,CAAC;AACH,eAAO,MAAM,YAAY;;EAA2C,CAAC;AAErE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CpB,CAAC;AAEhB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBxB,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;CAc1B,CAAC;AAEhB,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDxB,CAAC;AAEhB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B5B,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+B1B,CAAC"}

package/dist/__tests__/fixtures/services.js

@@ -1,207 +0,0 @@
-import { Type } from '@sinclair/typebox';
-import { ServiceBuilder } from '../../router/builder';
-import { Err, Ok } from '../../router/result';
-import { Observable } from './observable';
-export const EchoRequest = Type.Object({
-    msg: Type.String(),
-    ignore: Type.Boolean(),
-    end: Type.Optional(Type.Boolean()),
-});
-export const EchoResponse = Type.Object({ response: Type.String() });
-export const TestServiceConstructor = () => ServiceBuilder.create('test')
-    .initialState({
-    count: 0,
-})
-    .defineProcedure('add', {
-    type: 'rpc',
-    input: Type.Object({ n: Type.Number() }),
-    output: Type.Object({ result: Type.Number() }),
-    errors: Type.Never(),
-    async handler(ctx, { n }) {
-        ctx.state.count += n;
-        return Ok({ result: ctx.state.count });
-    },
-})
-    .defineProcedure('echo', {
-    type: 'stream',
-    input: EchoRequest,
-    output: EchoResponse,
-    errors: Type.Never(),
-    async handler(_ctx, msgStream, returnStream) {
-        for await (const { ignore, msg, end } of msgStream) {
-            if (!ignore) {
-                returnStream.push(Ok({ response: msg }));
-            }
-            if (end) {
-                returnStream.end();
-            }
-        }
-    },
-})
-    .defineProcedure('echoWithPrefix', {
-    type: 'stream',
-    init: Type.Object({ prefix: Type.String() }),
-    input: EchoRequest,
-    output: EchoResponse,
-    errors: Type.Never(),
-    async handler(_ctx, init, msgStream, returnStream) {
-        for await (const { ignore, msg } of msgStream) {
-            if (!ignore) {
-                returnStream.push(Ok({ response: `${init.prefix} ${msg}` }));
-            }
-        }
-    },
-})
-    .finalize();
-export const OrderingServiceConstructor = () => ServiceBuilder.create('test')
-    .initialState({
-    msgs: [],
-})
-    .defineProcedure('add', {
-    type: 'rpc',
-    input: Type.Object({ n: Type.Number() }),
-    output: Type.Object({ n: Type.Number() }),
-    errors: Type.Never(),
-    async handler(ctx, { n }) {
-        ctx.state.msgs.push(n);
-        return Ok({ n });
-    },
-})
-    .defineProcedure('getAll', {
-    type: 'rpc',
-    input: Type.Object({}),
-    output: Type.Object({ msgs: Type.Array(Type.Number()) }),
-    errors: Type.Never(),
-    async handler(ctx, _msg) {
-        return Ok({ msgs: ctx.state.msgs });
-    },
-})
-    .finalize();
-export const BinaryFileServiceConstructor = () => ServiceBuilder.create('bin')
-    .defineProcedure('getFile', {
-    type: 'rpc',
-    input: Type.Object({ file: Type.String() }),
-    output: Type.Object({ contents: Type.Uint8Array() }),
-    errors: Type.Never(),
-    async handler(_ctx, { file }) {
-        const bytes = new TextEncoder().encode(`contents for file ${file}`);
-        return Ok({ contents: bytes });
-    },
-})
-    .finalize();
-export const DIV_BY_ZERO = 'DIV_BY_ZERO';
-export const STREAM_ERROR = 'STREAM_ERROR';
-export const FallibleServiceConstructor = () => ServiceBuilder.create('fallible')
-    .initialState({})
-    .defineProcedure('divide', {
-    type: 'rpc',
-    input: Type.Object({ a: Type.Number(), b: Type.Number() }),
-    output: Type.Object({ result: Type.Number() }),
-    errors: Type.Union([
-        Type.Object({
-            code: Type.Literal(DIV_BY_ZERO),
-            message: Type.String(),
-            extras: Type.Object({ test: Type.String() }),
-        }),
-    ]),
-    async handler(_ctx, { a, b }) {
-        if (b === 0) {
-            return Err({
-                code: DIV_BY_ZERO,
-                message: 'Cannot divide by zero',
-                extras: { test: 'abc' },
-            });
-        }
-        else {
-            return Ok({ result: a / b });
-        }
-    },
-})
-    .defineProcedure('echo', {
-    type: 'stream',
-    input: Type.Object({
-        msg: Type.String(),
-        throwResult: Type.Boolean(),
-        throwError: Type.Boolean(),
-    }),
-    output: Type.Object({ response: Type.String() }),
-    errors: Type.Union([
-        Type.Object({
-            code: Type.Literal(STREAM_ERROR),
-            message: Type.String(),
-        }),
-    ]),
-    async handler(_ctx, msgStream, returnStream) {
-        for await (const { msg, throwError, throwResult } of msgStream) {
-            if (throwError) {
-                throw new Error('some message');
-            }
-            else if (throwResult) {
-                returnStream.push(Err({
-                    code: STREAM_ERROR,
-                    message: 'field throwResult was set to true',
-                }));
-            }
-            else {
-                returnStream.push(Ok({ response: msg }));
-            }
-        }
-    },
-})
-    .finalize();
-export const SubscribableServiceConstructor = () => ServiceBuilder.create('subscribable')
-    .initialState({
-    count: new Observable(0),
-})
-    .defineProcedure('add', {
-    type: 'rpc',
-    input: Type.Object({ n: Type.Number() }),
-    output: Type.Object({ result: Type.Number() }),
-    errors: Type.Never(),
-    async handler(ctx, { n }) {
-        ctx.state.count.set((prev) => prev + n);
-        return Ok({ result: ctx.state.count.get() });
-    },
-})
-    .defineProcedure('value', {
-    type: 'subscription',
-    input: Type.Object({}),
-    output: Type.Object({ result: Type.Number() }),
-    errors: Type.Never(),
-    async handler(ctx, _msg, returnStream) {
-        ctx.state.count.observe((count) => {
-            returnStream.push(Ok({ result: count }));
-        });
-    },
-})
-    .finalize();
-export const UploadableServiceConstructor = () => ServiceBuilder.create('uploadable')
-    .initialState({})
-    .defineProcedure('addMultiple', {
-    type: 'upload',
-    input: Type.Object({ n: Type.Number() }),
-    output: Type.Object({ result: Type.Number() }),
-    errors: Type.Never(),
-    async handler(_ctx, msgStream) {
-        let result = 0;
-        for await (const { n } of msgStream) {
-            result += n;
-        }
-        return Ok({ result: result });
-    },
-})
-    .defineProcedure('addMultipleWithPrefix', {
-    type: 'upload',
-    init: Type.Object({ prefix: Type.String() }),
-    input: Type.Object({ n: Type.Number() }),
-    output: Type.Object({ result: Type.String() }),
-    errors: Type.Never(),
-    async handler(_ctx, init, msgStream) {
-        let result = 0;
-        for await (const { n } of msgStream) {
-            result += n;
-        }
-        return Ok({ result: init.prefix + ' ' + result });
-    },
-})
-    .finalize();

package/dist/__tests__/handler.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=handler.test.d.ts.map

package/dist/__tests__/handler.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handler.test.d.ts","sourceRoot":"","sources":["../../__tests__/handler.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/handler.test.js

@@ -1,120 +0,0 @@
-import { asClientRpc, asClientStream, asClientSubscription, asClientUpload, iterNext, } from '../util/testHelpers';
-import { assert, describe, expect, test } from 'vitest';
-import { DIV_BY_ZERO, FallibleServiceConstructor, STREAM_ERROR, SubscribableServiceConstructor, UploadableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
-import { UNCAUGHT_ERROR } from '../router/result';
-import { Observable } from './fixtures/observable';
-describe('server-side test', () => {
-    const service = TestServiceConstructor();
-    test('rpc basic', async () => {
-        const add = asClientRpc({ count: 0 }, service.procedures.add);
-        const result = await add({ n: 3 });
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 3 });
-    });
-    test('rpc initial state', async () => {
-        const add = asClientRpc({ count: 5 }, service.procedures.add);
-        const result = await add({ n: 6 });
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 11 });
-    });
-    test('fallible rpc', async () => {
-        const service = FallibleServiceConstructor();
-        const divide = asClientRpc({}, service.procedures.divide);
-        const result = await divide({ a: 10, b: 2 });
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 5 });
-        const result2 = await divide({ a: 10, b: 0 });
-        assert(!result2.ok);
-        expect(result2.payload).toStrictEqual({
-            code: DIV_BY_ZERO,
-            message: 'Cannot divide by zero',
-            extras: {
-                test: 'abc',
-            },
-        });
-    });
-    test('stream basic', async () => {
-        const [input, output] = asClientStream({ count: 0 }, service.procedures.echo);
-        input.push({ msg: 'abc', ignore: false });
-        input.push({ msg: 'def', ignore: true });
-        input.push({ msg: 'ghi', ignore: false });
-        input.end();
-        const result1 = await iterNext(output);
-        assert(result1 && result1.ok);
-        expect(result1.payload).toStrictEqual({ response: 'abc' });
-        const result2 = await iterNext(output);
-        assert(result2 && result2.ok);
-        expect(result2.payload).toStrictEqual({ response: 'ghi' });
-        expect(output.readableLength).toBe(0);
-    });
-    test('stream with initialization', async () => {
-        const [input, output] = asClientStream({ count: 0 }, service.procedures.echoWithPrefix, { prefix: 'test' });
-        input.push({ msg: 'abc', ignore: false });
-        input.push({ msg: 'def', ignore: true });
-        input.push({ msg: 'ghi', ignore: false });
-        input.end();
-        const result1 = await iterNext(output);
-        assert(result1 && result1.ok);
-        expect(result1.payload).toStrictEqual({ response: 'test abc' });
-        const result2 = await iterNext(output);
-        assert(result2 && result2.ok);
-        expect(result2.payload).toStrictEqual({ response: 'test ghi' });
-        expect(output.readableLength).toBe(0);
-    });
-    test('fallible stream', async () => {
-        const service = FallibleServiceConstructor();
-        const [input, output] = asClientStream({}, service.procedures.echo);
-        input.push({ msg: 'abc', throwResult: false, throwError: false });
-        const result1 = await iterNext(output);
-        assert(result1 && result1.ok);
-        expect(result1.payload).toStrictEqual({ response: 'abc' });
-        input.push({ msg: 'def', throwResult: true, throwError: false });
-        const result2 = await iterNext(output);
-        assert(result2 && !result2.ok);
-        expect(result2.payload.code).toStrictEqual(STREAM_ERROR);
-        input.push({ msg: 'ghi', throwResult: false, throwError: true });
-        const result3 = await iterNext(output);
-        assert(result3 && !result3.ok);
-        expect(result3.payload).toStrictEqual({
-            code: UNCAUGHT_ERROR,
-            message: 'some message',
-        });
-        input.end();
-        expect(output.readableLength).toBe(0);
-    });
-    test('subscriptions', async () => {
-        const service = SubscribableServiceConstructor();
-        const state = { count: new Observable(0) };
-        const add = asClientRpc(state, service.procedures.add);
-        const subscribe = asClientSubscription(state, service.procedures.value);
-        const stream = await subscribe({});
-        const streamResult1 = await iterNext(stream);
-        assert(streamResult1 && streamResult1.ok);
-        expect(streamResult1.payload).toStrictEqual({ result: 0 });
-        const result = await add({ n: 3 });
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 3 });
-        const streamResult2 = await iterNext(stream);
-        assert(streamResult2 && streamResult1.ok);
-        expect(streamResult2.payload).toStrictEqual({ result: 3 });
-    });
-    test('uploads', async () => {
-        const service = UploadableServiceConstructor();
-        const [input, result] = await asClientUpload({}, service.procedures.addMultiple);
-        input.push({ n: 1 });
-        input.push({ n: 2 });
-        input.end();
-        expect(await result).toStrictEqual({ ok: true, payload: { result: 3 } });
-    });
-    test('uploads with initialization', async () => {
-        const service = UploadableServiceConstructor();
-        const [input, result] = await asClientUpload({}, service.procedures.addMultipleWithPrefix, { prefix: 'test' });
-        input.push({ n: 1 });
-        input.push({ n: 2 });
-        input.end();
-        expect(await result).toStrictEqual({
-            ok: true,
-            payload: { result: 'test 3' },
-        });
-    });
-});

package/dist/__tests__/serialize.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=serialize.test.d.ts.map

package/dist/__tests__/serialize.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serialize.test.d.ts","sourceRoot":"","sources":["../../__tests__/serialize.test.ts"],"names":[],"mappings":""}