@hazeljs/core 0.2.0-beta.1

package/dist/__tests__/middleware/security-headers.test.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const security_headers_middleware_1 = require("../../middleware/security-headers.middleware");
+describe('SecurityHeadersMiddleware', () => {
+    let mockReq;
+    let mockRes;
+    let nextFn;
+    beforeEach(() => {
+        mockReq = {
+            method: 'GET',
+            url: '/test',
+            headers: {},
+        };
+        mockRes = {
+            setHeader: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn(),
+        };
+        nextFn = jest.fn();
+    });
+    describe('default options', () => {
+        it('should set default security headers', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware();
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('X-Content-Type-Options', 'nosniff');
+            expect(mockRes.setHeader).toHaveBeenCalledWith('X-Frame-Options', 'DENY');
+            expect(mockRes.setHeader).toHaveBeenCalledWith('X-XSS-Protection', '1; mode=block');
+            expect(mockRes.setHeader).toHaveBeenCalledWith('X-Powered-By', '');
+            expect(nextFn).toHaveBeenCalled();
+        });
+    });
+    describe('X-Content-Type-Options', () => {
+        it('should set nosniff header when enabled', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({ noSniff: true });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('X-Content-Type-Options', 'nosniff');
+        });
+        it('should not set nosniff header when disabled', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({ noSniff: false });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).not.toHaveBeenCalledWith('X-Content-Type-Options', 'nosniff');
+        });
+    });
+    describe('X-Frame-Options', () => {
+        it('should set DENY by default', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware();
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('X-Frame-Options', 'DENY');
+        });
+        it('should set SAMEORIGIN when specified', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({ frameOptions: 'SAMEORIGIN' });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('X-Frame-Options', 'SAMEORIGIN');
+        });
+        it('should set custom value', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({ frameOptions: 'ALLOW-FROM https://example.com' });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('X-Frame-Options', 'ALLOW-FROM https://example.com');
+        });
+    });
+    describe('X-XSS-Protection', () => {
+        it('should set XSS protection header when enabled', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({ xssProtection: true });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('X-XSS-Protection', '1; mode=block');
+        });
+        it('should not set XSS protection header when disabled', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({ xssProtection: false });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).not.toHaveBeenCalledWith('X-XSS-Protection', expect.any(String));
+        });
+    });
+    describe('Strict-Transport-Security (HSTS)', () => {
+        it('should set HSTS header in production', () => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'production';
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware();
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Strict-Transport-Security', expect.stringContaining('max-age=31536000'));
+            process.env.NODE_ENV = originalEnv;
+        });
+        it('should set HSTS with custom max-age', () => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'production';
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({
+                hsts: { maxAge: 7200 },
+            });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Strict-Transport-Security', expect.stringContaining('max-age=7200'));
+            process.env.NODE_ENV = originalEnv;
+        });
+        it('should include includeSubDomains when specified', () => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'production';
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({
+                hsts: { includeSubDomains: true },
+            });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Strict-Transport-Security', expect.stringContaining('includeSubDomains'));
+            process.env.NODE_ENV = originalEnv;
+        });
+        it('should include preload when specified', () => {
+            const originalEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = 'production';
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({
+                hsts: { preload: true },
+            });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Strict-Transport-Security', expect.stringContaining('preload'));
+            process.env.NODE_ENV = originalEnv;
+        });
+        it('should set HSTS for HTTPS requests', () => {
+            mockReq.headers = { 'x-forwarded-proto': 'https' };
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware();
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Strict-Transport-Security', expect.any(String));
+        });
+    });
+    describe('Content-Security-Policy', () => {
+        it('should set CSP from string', () => {
+            const csp = "default-src 'self'; script-src 'self' 'unsafe-inline'";
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({
+                contentSecurityPolicy: csp,
+            });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Content-Security-Policy', csp);
+        });
+        it('should build CSP from object', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({
+                contentSecurityPolicy: {
+                    defaultSrc: ["'self'"],
+                    scriptSrc: ["'self'", "'unsafe-inline'"],
+                },
+            });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Content-Security-Policy', "default-src 'self'; script-src 'self' 'unsafe-inline'");
+        });
+        it('should include all CSP directives', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({
+                contentSecurityPolicy: {
+                    defaultSrc: ["'self'"],
+                    scriptSrc: ["'self'"],
+                    styleSrc: ["'self'"],
+                    imgSrc: ["'self'", 'data:'],
+                    connectSrc: ["'self'"],
+                    fontSrc: ["'self'"],
+                    objectSrc: ["'none'"],
+                    mediaSrc: ["'self'"],
+                    frameSrc: ["'none'"],
+                    baseUri: ["'self'"],
+                    formAction: ["'self'"],
+                    frameAncestors: ["'none'"],
+                    upgradeInsecureRequests: true,
+                },
+            });
+            middleware.use(mockReq, mockRes, nextFn);
+            const cspCall = mockRes.setHeader.mock.calls.find((call) => call[0] === 'Content-Security-Policy');
+            expect(cspCall).toBeDefined();
+            expect(cspCall[1]).toContain('default-src');
+            expect(cspCall[1]).toContain('script-src');
+            expect(cspCall[1]).toContain('upgrade-insecure-requests');
+        });
+    });
+    describe('Referrer-Policy', () => {
+        it('should set referrer policy', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({
+                referrerPolicy: 'no-referrer',
+            });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Referrer-Policy', 'no-referrer');
+        });
+        it('should support different referrer policies', () => {
+            const policies = [
+                'no-referrer',
+                'no-referrer-when-downgrade',
+                'origin',
+                'origin-when-cross-origin',
+                'same-origin',
+                'strict-origin',
+                'strict-origin-when-cross-origin',
+                'unsafe-url',
+            ];
+            policies.forEach((policy) => {
+                jest.clearAllMocks();
+                const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({ referrerPolicy: policy });
+                middleware.use(mockReq, mockRes, nextFn);
+                expect(mockRes.setHeader).toHaveBeenCalledWith('Referrer-Policy', policy);
+            });
+        });
+    });
+    describe('Permissions-Policy', () => {
+        it('should set permissions policy', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({
+                permissionsPolicy: {
+                    geolocation: [],
+                    camera: ["'self'"],
+                },
+            });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('Permissions-Policy', "geolocation=(), camera=('self')");
+        });
+        it('should handle multiple permissions', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({
+                permissionsPolicy: {
+                    geolocation: [],
+                    microphone: [],
+                    camera: ["'self'"],
+                },
+            });
+            middleware.use(mockReq, mockRes, nextFn);
+            const permissionsCall = mockRes.setHeader.mock.calls.find((call) => call[0] === 'Permissions-Policy');
+            expect(permissionsCall[1]).toContain('geolocation=()');
+            expect(permissionsCall[1]).toContain('microphone=()');
+            expect(permissionsCall[1]).toContain("camera=('self')");
+        });
+    });
+    describe('X-Powered-By', () => {
+        it('should hide X-Powered-By by default', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware();
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).toHaveBeenCalledWith('X-Powered-By', '');
+        });
+        it('should not hide X-Powered-By when disabled', () => {
+            const middleware = new security_headers_middleware_1.SecurityHeadersMiddleware({ hidePoweredBy: false });
+            middleware.use(mockReq, mockRes, nextFn);
+            expect(mockRes.setHeader).not.toHaveBeenCalledWith('X-Powered-By', '');
+        });
+    });
+});

package/dist/__tests__/middleware/timeout.test.d.ts

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

package/dist/__tests__/middleware/timeout.test.d.ts.map

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

package/dist/__tests__/middleware/timeout.test.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const timeout_middleware_1 = require("../../middleware/timeout.middleware");
+// Mock logger
+jest.mock('../../logger', () => ({
+    warn: jest.fn(),
+    error: jest.fn(),
+}));
+describe('TimeoutMiddleware', () => {
+    let mockReq;
+    let mockRes;
+    let nextFn;
+    beforeEach(() => {
+        jest.useFakeTimers();
+        mockReq = {
+            method: 'GET',
+            url: '/test',
+        };
+        mockRes = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn(),
+            end: jest.fn(),
+            setHeader: jest.fn(),
+        };
+        nextFn = jest.fn();
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    describe('constructor', () => {
+        it('should use default timeout of 30 seconds', () => {
+            const middleware = new timeout_middleware_1.TimeoutMiddleware();
+            expect(middleware).toBeDefined();
+        });
+        it('should accept custom timeout', () => {
+            const middleware = new timeout_middleware_1.TimeoutMiddleware({ timeout: 5000 });
+            expect(middleware).toBeDefined();
+        });
+        it('should accept custom message', () => {
+            const middleware = new timeout_middleware_1.TimeoutMiddleware({ message: 'Custom timeout' });
+            expect(middleware).toBeDefined();
+        });
+    });
+    describe('handle', () => {
+        it('should call next if request completes before timeout', () => {
+            const middleware = new timeout_middleware_1.TimeoutMiddleware({ timeout: 1000 });
+            middleware.handle(mockReq, mockRes, nextFn);
+            expect(nextFn).toHaveBeenCalled();
+            expect(mockRes.status).not.toHaveBeenCalled();
+        });
+        it('should send 408 response on timeout', () => {
+            const middleware = new timeout_middleware_1.TimeoutMiddleware({ timeout: 1000 });
+            middleware.handle(mockReq, mockRes, nextFn);
+            jest.advanceTimersByTime(1000);
+            expect(mockRes.status).toHaveBeenCalledWith(408);
+            expect(mockRes.json).toHaveBeenCalledWith({
+                statusCode: 408,
+                message: 'Request timeout',
+                error: 'Request Timeout',
+            });
+        });
+        it('should use custom timeout message', () => {
+            const middleware = new timeout_middleware_1.TimeoutMiddleware({
+                timeout: 1000,
+                message: 'Custom timeout message',
+            });
+            middleware.handle(mockReq, mockRes, nextFn);
+            jest.advanceTimersByTime(1000);
+            expect(mockRes.json).toHaveBeenCalledWith({
+                statusCode: 408,
+                message: 'Custom timeout message',
+                error: 'Request Timeout',
+            });
+        });
+        it('should call onTimeout callback when timeout occurs', () => {
+            const onTimeoutMock = jest.fn();
+            const middleware = new timeout_middleware_1.TimeoutMiddleware({
+                timeout: 1000,
+                onTimeout: onTimeoutMock,
+            });
+            middleware.handle(mockReq, mockRes, nextFn);
+            jest.advanceTimersByTime(1000);
+            expect(onTimeoutMock).toHaveBeenCalledWith(mockReq);
+        });
+        it('should handle errors in onTimeout callback gracefully', () => {
+            const onTimeoutMock = jest.fn(() => {
+                throw new Error('Callback error');
+            });
+            const middleware = new timeout_middleware_1.TimeoutMiddleware({
+                timeout: 1000,
+                onTimeout: onTimeoutMock,
+            });
+            middleware.handle(mockReq, mockRes, nextFn);
+            jest.advanceTimersByTime(1000);
+            // Should still send timeout response despite callback error
+            expect(mockRes.status).toHaveBeenCalledWith(408);
+        });
+        it('should clear timeout when response ends', () => {
+            const middleware = new timeout_middleware_1.TimeoutMiddleware({ timeout: 5000 });
+            middleware.handle(mockReq, mockRes, nextFn);
+            // Simulate response ending
+            mockRes.end();
+            // Advance past timeout
+            jest.advanceTimersByTime(6000);
+            // Should not send timeout response
+            expect(mockRes.status).not.toHaveBeenCalled();
+        });
+        it('should wrap res.end to clear timeout', () => {
+            const originalEnd = mockRes.end;
+            const middleware = new timeout_middleware_1.TimeoutMiddleware({ timeout: 1000 });
+            middleware.handle(mockReq, mockRes, nextFn);
+            expect(mockRes.end).not.toBe(originalEnd);
+        });
+    });
+    describe('create static method', () => {
+        it('should create middleware function', () => {
+            const middlewareFn = timeout_middleware_1.TimeoutMiddleware.create({ timeout: 1000 });
+            expect(typeof middlewareFn).toBe('function');
+        });
+        it('should create working middleware', () => {
+            const middlewareFn = timeout_middleware_1.TimeoutMiddleware.create({ timeout: 1000 });
+            middlewareFn(mockReq, mockRes, nextFn);
+            expect(nextFn).toHaveBeenCalled();
+        });
+        it('should trigger timeout with created middleware', () => {
+            const middlewareFn = timeout_middleware_1.TimeoutMiddleware.create({ timeout: 500 });
+            middlewareFn(mockReq, mockRes, nextFn);
+            jest.advanceTimersByTime(500);
+            expect(mockRes.status).toHaveBeenCalledWith(408);
+        });
+    });
+});

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

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

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

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

package/dist/__tests__/middleware.test.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const middleware_1 = require("../middleware");
+const container_1 = require("../container");
+// Mock logger
+jest.mock('../logger', () => ({
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    isDebugEnabled: jest.fn().mockReturnValue(false),
+}));
+describe('MiddlewareHandler', () => {
+    let handler;
+    let container;
+    let context;
+    beforeEach(() => {
+        container = container_1.Container.createTestInstance();
+        handler = new middleware_1.MiddlewareHandler(container);
+        context = {
+            method: 'GET',
+            url: '/test',
+            headers: {},
+            params: {},
+            query: {},
+            body: {},
+        };
+    });
+    describe('executeMiddlewareChain', () => {
+        it('should execute final handler when no middlewares', async () => {
+            const finalHandler = jest.fn().mockResolvedValue({ data: 'result' });
+            const result = await handler.executeMiddlewareChain([], context, finalHandler);
+            expect(finalHandler).toHaveBeenCalled();
+            expect(result).toEqual({ data: 'result' });
+        });
+        it('should execute single middleware', async () => {
+            class TestMiddleware {
+                async use(ctx, next) {
+                    return next();
+                }
+            }
+            container.registerProvider({ token: TestMiddleware, useClass: TestMiddleware });
+            const finalHandler = jest.fn().mockResolvedValue({ data: 'result' });
+            const result = await handler.executeMiddlewareChain([TestMiddleware], context, finalHandler);
+            expect(result).toEqual({ data: 'result' });
+        });
+        it('should execute multiple middlewares in order', async () => {
+            const executionOrder = [];
+            class Middleware1 {
+                async use(ctx, next) {
+                    executionOrder.push(1);
+                    const result = await next();
+                    executionOrder.push(4);
+                    return result;
+                }
+            }
+            class Middleware2 {
+                async use(ctx, next) {
+                    executionOrder.push(2);
+                    const result = await next();
+                    executionOrder.push(3);
+                    return result;
+                }
+            }
+            container.registerProvider({ token: Middleware1, useClass: Middleware1 });
+            container.registerProvider({ token: Middleware2, useClass: Middleware2 });
+            const finalHandler = jest.fn().mockResolvedValue({ data: 'result' });
+            await handler.executeMiddlewareChain([Middleware1, Middleware2], context, finalHandler);
+            expect(executionOrder).toEqual([1, 2, 3, 4]);
+        });
+        it('should pass context through middleware chain', async () => {
+            let capturedContext = null;
+            class TestMiddleware {
+                async use(ctx, next) {
+                    capturedContext = ctx;
+                    return next();
+                }
+            }
+            container.registerProvider({ token: TestMiddleware, useClass: TestMiddleware });
+            const finalHandler = jest.fn().mockResolvedValue({});
+            await handler.executeMiddlewareChain([TestMiddleware], context, finalHandler);
+            expect(capturedContext).toBe(context);
+        });
+        it('should allow middleware to modify result', async () => {
+            class TransformMiddleware {
+                async use(ctx, next) {
+                    const result = (await next());
+                    return { ...result, transformed: true };
+                }
+            }
+            container.registerProvider({ token: TransformMiddleware, useClass: TransformMiddleware });
+            const finalHandler = jest.fn().mockResolvedValue({ data: 'original' });
+            const result = await handler.executeMiddlewareChain([TransformMiddleware], context, finalHandler);
+            expect(result).toEqual({ data: 'original', transformed: true });
+        });
+        it('should handle middleware errors', async () => {
+            class ErrorMiddleware {
+                async use(_ctx, _next) {
+                    throw new Error('Middleware error');
+                }
+            }
+            container.registerProvider({ token: ErrorMiddleware, useClass: ErrorMiddleware });
+            const finalHandler = jest.fn();
+            await expect(handler.executeMiddlewareChain([ErrorMiddleware], context, finalHandler)).rejects.toThrow('Middleware error');
+        });
+        it('should add status code to errors without one', async () => {
+            class ErrorMiddleware {
+                async use(_ctx, _next) {
+                    const error = new Error('Test error');
+                    throw error;
+                }
+            }
+            container.registerProvider({ token: ErrorMiddleware, useClass: ErrorMiddleware });
+            const finalHandler = jest.fn();
+            try {
+                await handler.executeMiddlewareChain([ErrorMiddleware], context, finalHandler);
+                fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error.status).toBe(500);
+            }
+        });
+        it('should preserve existing status code on errors', async () => {
+            class ErrorMiddleware {
+                async use(_ctx, _next) {
+                    const error = new Error('Test error');
+                    error.status = 400;
+                    throw error;
+                }
+            }
+            container.registerProvider({ token: ErrorMiddleware, useClass: ErrorMiddleware });
+            const finalHandler = jest.fn();
+            try {
+                await handler.executeMiddlewareChain([ErrorMiddleware], context, finalHandler);
+                fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error.status).toBe(400);
+            }
+        });
+        it('should handle final handler errors', async () => {
+            const finalHandler = jest.fn().mockRejectedValue(new Error('Handler error'));
+            await expect(handler.executeMiddlewareChain([], context, finalHandler)).rejects.toThrow('Handler error');
+        });
+        it('should add status to final handler errors', async () => {
+            const finalHandler = jest.fn().mockRejectedValue(new Error('Handler error'));
+            try {
+                await handler.executeMiddlewareChain([], context, finalHandler);
+                fail('Should have thrown error');
+            }
+            catch (error) {
+                expect(error.status).toBe(500);
+            }
+        });
+        it('should allow middleware to short-circuit chain', async () => {
+            class ShortCircuitMiddleware {
+                async use(_ctx, _next) {
+                    return { shortCircuited: true };
+                }
+            }
+            container.registerProvider({ token: ShortCircuitMiddleware, useClass: ShortCircuitMiddleware });
+            const finalHandler = jest.fn();
+            const result = await handler.executeMiddlewareChain([ShortCircuitMiddleware], context, finalHandler);
+            expect(result).toEqual({ shortCircuited: true });
+            expect(finalHandler).not.toHaveBeenCalled();
+        });
+        it('should handle async middleware', async () => {
+            class AsyncMiddleware {
+                async use(ctx, next) {
+                    await new Promise((resolve) => setTimeout(resolve, 10));
+                    return next();
+                }
+            }
+            container.registerProvider({ token: AsyncMiddleware, useClass: AsyncMiddleware });
+            const finalHandler = jest.fn().mockResolvedValue({ data: 'result' });
+            const result = await handler.executeMiddlewareChain([AsyncMiddleware], context, finalHandler);
+            expect(result).toEqual({ data: 'result' });
+        });
+    });
+});

package/dist/__tests__/pipes/pipe.test.d.ts

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

package/dist/__tests__/pipes/pipe.test.d.ts.map

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