yxorp 0.1.5 → 0.2.0

package/dist/middleware/mock.middleware.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockMiddleware = void 0;
+const mime_1 = __importDefault(require("mime"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+class MockMiddleware {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async use(req, res, next) {
+        try {
+            const mockRule = req === null || req === void 0 ? void 0 : req.mockRule;
+            if (!mockRule) {
+                next();
+                return;
+            }
+            if ('script' in mockRule) {
+                const fullPath = path_1.default.resolve(mockRule.script);
+                delete require.cache[require.resolve(fullPath)];
+                const handler = require(fullPath);
+                if (typeof handler === 'function') {
+                    await handler(req, res);
+                    if (!res.headersSent) {
+                        res.setHeader('content-type', 'application/json');
+                    }
+                }
+                this.logger.info(`mock         ${res.statusCode || 200} ${req.method} ${req.url}`);
+                return;
+            }
+            if ('file' in mockRule) {
+                const file = await promises_1.default.readFile(path_1.default.resolve(mockRule.file));
+                const mimeType = mime_1.default.getType(path_1.default.resolve(mockRule.file));
+                res.statusCode = mockRule.statusCode || res.statusCode;
+                if (mimeType) {
+                    res.setHeader('content-type', mimeType);
+                }
+                res.setHeader('content-length', file.length);
+                res.end(file);
+                this.logger.info(`mock         ${res.statusCode} ${req.method} ${req.url}`);
+                return;
+            }
+            next();
+        }
+        catch (e) {
+            this.logger.error(e);
+            next();
+        }
+    }
+}
+exports.MockMiddleware = MockMiddleware;

package/dist/middleware/proxy.middleware.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { HttpProxy } from '../services/http-proxy.service';
+import { RemoteRulesMatcher } from '../services/rules-matchers/remote-rules-matcher.service';
+import { Config } from '../services/config.service';
+import { Middleware } from '../services/pipeline.service';
+import { LoggerService } from '../services/logger.service';
+export declare class ProxyMiddleware implements Middleware<[req: IncomingMessage, res: ServerResponse]> {
+    private httpProxy;
+    private remoteRulesMatcher;
+    private config;
+    private logger;
+    constructor(httpProxy: HttpProxy, remoteRulesMatcher: RemoteRulesMatcher, config: Config, logger: LoggerService);
+    use(req: IncomingMessage, res: ServerResponse): void;
+}

package/dist/middleware/proxy.middleware.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyMiddleware = void 0;
+class ProxyMiddleware {
+    constructor(httpProxy, remoteRulesMatcher, config, logger) {
+        this.httpProxy = httpProxy;
+        this.remoteRulesMatcher = remoteRulesMatcher;
+        this.config = config;
+        this.logger = logger;
+    }
+    use(req, res) {
+        const url = req.url || '';
+        const proxyOptions = this.config.get().proxyOptions;
+        const remoteRule = this.remoteRulesMatcher.match(url);
+        const target = remoteRule
+            ? this.remoteRulesMatcher.toPath(url, remoteRule)
+            : undefined;
+        const options = {
+            ...proxyOptions,
+            prependPath: !target,
+            target: target || proxyOptions.target,
+        };
+        this.httpProxy.web(req, res, options).catch((error) => this.logger.error(error));
+    }
+}
+exports.ProxyMiddleware = ProxyMiddleware;

package/dist/middleware/proxyRes.middleware.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { Middleware } from '../services/pipeline.service';
+import { LoggerService } from '../services/logger.service';
+export declare class ProxyResMiddleware implements Middleware<[proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse]> {
+    private logger;
+    constructor(logger: LoggerService);
+    use(proxyRes: IncomingMessage, _req: IncomingMessage, res: ServerResponse): void;
+}

package/dist/middleware/proxyRes.middleware.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyResMiddleware = void 0;
+class ProxyResMiddleware {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    use(proxyRes, _req, res) {
+        try {
+            // Skip transfer-encoding since we reconstruct the body with known length
+            for (let key in proxyRes.headers) {
+                if (key === 'transfer-encoding')
+                    continue;
+                res.setHeader(key, proxyRes.headers[key]);
+            }
+            res.statusCode = proxyRes.statusCode;
+            res.statusMessage = proxyRes.statusMessage;
+            const response = proxyRes.rawBody || Buffer.from('');
+            res.removeHeader('content-length');
+            res.setHeader('content-length', response.length);
+            res.end(response);
+        }
+        catch (e) {
+            this.logger.error(e);
+        }
+    }
+}
+exports.ProxyResMiddleware = ProxyResMiddleware;

package/dist/middleware/rawBody.middleware.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { Middleware } from '../services/pipeline.service';
+export declare class RawBodyMiddleware implements Middleware<[proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse]> {
+    use(proxyRes: IncomingMessage, _req: IncomingMessage, _res: ServerResponse, next: () => void): Promise<void>;
+}

package/dist/middleware/rawBody.middleware.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawBodyMiddleware = void 0;
+class RawBodyMiddleware {
+    use(proxyRes, _req, _res, next) {
+        return new Promise((resolve, reject) => {
+            const body = [];
+            proxyRes.on('data', (chunk) => {
+                body.push(chunk);
+            });
+            proxyRes.on('end', () => {
+                proxyRes.rawBody = Buffer.concat(body);
+                next();
+                resolve();
+            });
+            proxyRes.on('error', (err) => {
+                proxyRes.rawBody = Buffer.concat(body);
+                next();
+                reject(err);
+            });
+        });
+    }
+}
+exports.RawBodyMiddleware = RawBodyMiddleware;

package/dist/middleware/rewrite.middleware.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { Middleware } from '../services/pipeline.service';
+import { LoggerService } from '../services/logger.service';
+export declare class RewriteMiddleware implements Middleware<[proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse]> {
+    private logger;
+    constructor(logger: LoggerService);
+    use(proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse, next: () => void): Promise<void>;
+}

package/dist/middleware/rewrite.middleware.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewriteMiddleware = void 0;
+const http_encoding_1 = require("http-encoding");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+class RewriteMiddleware {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async use(proxyRes, req, res, next) {
+        const rewriteRule = req === null || req === void 0 ? void 0 : req.rewriteRule;
+        try {
+            if (!rewriteRule) {
+                next();
+                return;
+            }
+            const encoding = proxyRes.headers['content-encoding'];
+            const response = proxyRes.rawBody || Buffer.from('');
+            if ('script' in rewriteRule) {
+                const fullPath = path_1.default.resolve(rewriteRule.script);
+                delete require.cache[require.resolve(fullPath)];
+                const handler = require(fullPath);
+                if (typeof handler === 'function') {
+                    const encodedResponse = await (0, http_encoding_1.decodeBuffer)(response, encoding);
+                    const rewritedResponse = await handler(encodedResponse, proxyRes, req, res);
+                    proxyRes.rawBody = await (0, http_encoding_1.encodeBuffer)(rewritedResponse, encoding);
+                }
+                this.logger.info(`rewrite       ${proxyRes.statusCode} ${req.method} ${req.url}`);
+                next();
+                return;
+            }
+            if ('file' in rewriteRule) {
+                const file = await promises_1.default.readFile(path_1.default.resolve(rewriteRule.file));
+                proxyRes.rawBody = await (0, http_encoding_1.encodeBuffer)(file, encoding);
+                if (rewriteRule.statusCode) {
+                    proxyRes.statusCode = rewriteRule.statusCode;
+                }
+                this.logger.info(`rewrite       ${proxyRes.statusCode} ${req.method} ${req.url}`);
+                next();
+                return;
+            }
+            next();
+        }
+        catch (e) {
+            this.logger.error(e);
+            next();
+        }
+    }
+}
+exports.RewriteMiddleware = RewriteMiddleware;

package/dist/middleware/static.middleware.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { ServerResponse, IncomingMessage } from 'http';
+import { Config } from '../services/config.service';
+import { Middleware } from '../services/pipeline.service';
+import { LoggerService } from '../services/logger.service';
+export declare class StaticMiddleware implements Middleware<[req: IncomingMessage, res: ServerResponse]> {
+    private config;
+    private logger;
+    constructor(config: Config, logger: LoggerService);
+    use(req: IncomingMessage, res: ServerResponse, next: () => void): Promise<void>;
+    private readdir;
+}

package/dist/middleware/static.middleware.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticMiddleware = void 0;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const mime_1 = __importDefault(require("mime"));
+class StaticMiddleware {
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    async use(req, res, next) {
+        try {
+            const staticRules = this.config.get().staticRules || [];
+            const url = new URL(req.url || '', 'http://fake.com');
+            const urlPath = url.pathname;
+            if (!staticRules) {
+                next();
+                return;
+            }
+            const currentStaticRule = staticRules.filter((staticRule) => {
+                return urlPath.startsWith(staticRule.path);
+            })[0];
+            if (!currentStaticRule) {
+                next();
+                return;
+            }
+            const pathToDirectory = path_1.default.resolve(currentStaticRule.directory);
+            const dirents = await this.readdir(pathToDirectory);
+            const filePath = dirents
+                .filter(dirent => !dirent.isDirectory())
+                .map(dirent => ({
+                urlPath: path_1.default.join(currentStaticRule.path, path_1.default.join(dirent.path, dirent.name).replace(pathToDirectory, '')).replace(/\\/g, '/'),
+                path: path_1.default.join(dirent.path, dirent.name).replace(/\\/g, '/'),
+            }))
+                .filter(dirent => {
+                const pathname = path_1.default.extname(urlPath)
+                    ? urlPath
+                    : path_1.default.join(urlPath, currentStaticRule.directoryIndex || '').replace(/\\/g, '/');
+                if (currentStaticRule.caseInsensitive) {
+                    return dirent.urlPath.toLocaleLowerCase() === pathname.toLowerCase();
+                }
+                else {
+                    return dirent.urlPath === pathname;
+                }
+            })
+                .map(dirent => dirent.path)[0];
+            if (!filePath) {
+                next();
+                return;
+            }
+            const file = await promises_1.default.readFile(path_1.default.resolve(filePath));
+            const mimeType = mime_1.default.getType(path_1.default.resolve(filePath));
+            if (mimeType) {
+                res.setHeader('content-type', mimeType);
+            }
+            res.setHeader('content-length', file.length);
+            res.end(file);
+            this.logger.info(`static        ${res.statusCode} ${req.method} ${req.url}`);
+        }
+        catch (e) {
+            this.logger.error(e);
+            next();
+        }
+    }
+    async readdir(pathname, subpathname) {
+        const files = [];
+        const fullpath = path_1.default.join(pathname, subpathname || '');
+        const dirents = await promises_1.default.readdir(fullpath, {
+            withFileTypes: true,
+        });
+        for (let dirent of dirents) {
+            dirent.path = fullpath;
+            files.push(dirent);
+            if (dirent.isDirectory()) {
+                files.push(...await this.readdir(fullpath, dirent.name));
+            }
+        }
+        return files;
+    }
+}
+exports.StaticMiddleware = StaticMiddleware;

package/dist/services/config-resolver.d.ts

@@ -0,0 +1,6 @@
+import { ConfigFile } from '../types/yxorp-config';
+export interface ResolvedConfig {
+    configDir: string;
+    config: ConfigFile;
+}
+export declare function resolveConfig(cwd: string, argv: string[]): ResolvedConfig;

package/dist/services/config-resolver.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function resolveConfig(cwd, argv) {
+    // Parse --config CLI argument
+    const configArgIndex = argv.indexOf('--config');
+    let configFile;
+    if (configArgIndex !== -1 && configArgIndex + 1 < argv.length) {
+        configFile = argv[configArgIndex + 1];
+    }
+    if (configFile) {
+        const resolved = path_1.default.resolve(cwd, configFile);
+        if (!fs_1.default.existsSync(resolved)) {
+            throw new Error(`Config file not found: ${configFile}`);
+        }
+        return {
+            configDir: path_1.default.dirname(resolved),
+            config: JSON.parse(fs_1.default.readFileSync(resolved, 'utf-8')),
+        };
+    }
+    // Default: look for config in order of preference
+    const rootConfig = path_1.default.join(cwd, 'yxorp.json');
+    if (fs_1.default.existsSync(rootConfig)) {
+        return {
+            configDir: cwd,
+            config: JSON.parse(fs_1.default.readFileSync(rootConfig, 'utf-8')),
+        };
+    }
+    const dotDir = path_1.default.join(cwd, '.yxorp');
+    const dotConfig = path_1.default.join(dotDir, 'settings.json');
+    if (fs_1.default.existsSync(dotConfig)) {
+        return {
+            configDir: dotDir,
+            config: JSON.parse(fs_1.default.readFileSync(dotConfig, 'utf-8')),
+        };
+    }
+    throw new Error('Config file not found. Create yxorp.json or .yxorp/settings.json in the current directory, ' +
+        'or use --config <path> to specify a config file.');
+}
+exports.resolveConfig = resolveConfig;

package/dist/services/config.service.d.ts

@@ -0,0 +1,6 @@
+import { YxorpConfig } from '../types/yxorp-config';
+export declare class Config {
+    private config;
+    set(config: YxorpConfig): void;
+    get(): YxorpConfig;
+}

package/dist/services/config.service.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+class Config {
+    set(config) {
+        this.config = config;
+    }
+    get() {
+        return this.config;
+    }
+}
+exports.Config = Config;

package/dist/services/http-proxy.service.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { Pipeline } from './pipeline.service';
+export declare class HttpProxy {
+    private pipeline;
+    readonly on: (...args: any[]) => any;
+    private proxy;
+    constructor(pipeline: Pipeline<[proxyRes: IncomingMessage, req: IncomingMessage, res: ServerResponse]>);
+    execute: (args_0: IncomingMessage, args_1: IncomingMessage, args_2: ServerResponse<IncomingMessage>) => Promise<void>;
+    web(req: IncomingMessage, res: ServerResponse, options?: Record<string, any>): any;
+    ws(req: IncomingMessage, socket: any, options: Record<string, any>, head?: Buffer): any;
+}

package/dist/services/http-proxy.service.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpProxy = void 0;
+const httpxy_1 = require("httpxy");
+class HttpProxy {
+    constructor(pipeline) {
+        this.pipeline = pipeline;
+        this.execute = (...args) => this.pipeline.execute(...args);
+        this.proxy = (0, httpxy_1.createProxyServer)({});
+        this.on = this.proxy.on.bind(this.proxy);
+    }
+    web(req, res, options) {
+        return this.proxy.web(req, res, options);
+    }
+    ws(req, socket, options, head) {
+        return this.proxy.ws(req, socket, options, head);
+    }
+}
+exports.HttpProxy = HttpProxy;

package/dist/services/http-server.service.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { IncomingMessage, Server, ServerResponse } from 'http';
+import { Pipeline } from './pipeline.service';
+export declare class HttpServer {
+    private pipeline;
+    readonly use: Pipeline<[IncomingMessage, ServerResponse]>['use'];
+    readonly on: Server['on'];
+    readonly addListener: Server['addListener'];
+    readonly removeListener: Server['removeListener'];
+    readonly listen: Server['listen'];
+    readonly close: Server['close'];
+    readonly address: Server['address'];
+    private readonly server;
+    constructor(pipeline: Pipeline<[req: IncomingMessage, res: ServerResponse]>);
+}

package/dist/services/http-server.service.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpServer = void 0;
+const http_1 = __importDefault(require("http"));
+class HttpServer {
+    constructor(pipeline) {
+        this.pipeline = pipeline;
+        this.server = http_1.default.createServer((req, res) => {
+            this.pipeline.execute(req, res);
+        });
+        this.use = this.pipeline.use.bind(this.pipeline);
+        this.on = this.server.on.bind(this.server);
+        this.addListener = this.server.addListener.bind(this.server);
+        this.removeListener = this.server.removeListener.bind(this.server);
+        this.listen = this.server.listen.bind(this.server);
+        this.close = this.server.close.bind(this.server);
+        this.address = this.server.address.bind(this.server);
+    }
+}
+exports.HttpServer = HttpServer;

package/dist/services/logger.service.d.ts

@@ -0,0 +1,7 @@
+export declare class LoggerService {
+    private logger;
+    info: import("winston").LeveledLogMethod;
+    error: import("winston").LeveledLogMethod;
+    warn: import("winston").LeveledLogMethod;
+    debug: import("winston").LeveledLogMethod;
+}

package/dist/services/logger.service.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerService = void 0;
+const winston_1 = require("winston");
+class LoggerService {
+    constructor() {
+        this.logger = (0, winston_1.createLogger)({
+            format: winston_1.format.combine(winston_1.format.colorize(), winston_1.format.simple()),
+            transports: [new winston_1.transports.Console],
+        });
+        this.info = this.logger.info.bind(this.logger);
+        this.error = this.logger.error.bind(this.logger);
+        this.warn = this.logger.warn.bind(this.logger);
+        this.debug = this.logger.debug.bind(this.logger);
+    }
+}
+exports.LoggerService = LoggerService;

package/dist/services/pipeline.service.d.ts

@@ -0,0 +1,8 @@
+export interface Middleware<T extends any[]> {
+    use(...args: [...T, () => void]): void | Promise<void>;
+}
+export declare class Pipeline<T extends any[]> {
+    private stack;
+    use(...middlewares: Middleware<T>[]): void;
+    execute(...args: [...T]): Promise<void>;
+}

package/dist/services/pipeline.service.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pipeline = void 0;
+class Pipeline {
+    constructor() {
+        this.stack = [];
+    }
+    use(...middlewares) {
+        this.stack.push(...middlewares);
+    }
+    async execute(...args) {
+        let prevIndex = -1;
+        const runner = async (index) => {
+            if (index === prevIndex) {
+                throw new Error('next() called multiple times');
+            }
+            prevIndex = index;
+            const middleware = this.stack[index];
+            if (!middleware) {
+                return;
+            }
+            await middleware.use(...args, () => {
+                return runner(index + 1);
+            });
+        };
+        await runner(0);
+    }
+}
+exports.Pipeline = Pipeline;

package/dist/services/rules-matchers/mock-rules-matcher.service.d.ts

@@ -0,0 +1,8 @@
+import { Config } from '../config.service';
+import { MockRule } from '../../types/yxorp-config';
+export declare class MockRulesMatcher {
+    private config;
+    constructor(config: Config);
+    match(url: string, method: string): MockRule | undefined;
+    params(url: string, mockRule: MockRule): Object | undefined;
+}

package/dist/services/rules-matchers/mock-rules-matcher.service.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockRulesMatcher = void 0;
+const path_to_regexp_1 = require("path-to-regexp");
+class MockRulesMatcher {
+    constructor(config) {
+        this.config = config;
+    }
+    match(url, method) {
+        const mockRules = this.config.get().mockRules || [];
+        for (let mockRule of mockRules) {
+            if (mockRule.disable) {
+                continue;
+            }
+            if (mockRule.method.toLowerCase() !== method.toLowerCase()) {
+                continue;
+            }
+            const matchResult = (0, path_to_regexp_1.match)(mockRule.path, {
+                decode: decodeURIComponent,
+            })(url);
+            if (matchResult) {
+                return mockRule;
+            }
+        }
+    }
+    params(url, mockRule) {
+        const matchResult = (0, path_to_regexp_1.match)(mockRule.path, {
+            decode: decodeURIComponent,
+        })(url);
+        if (matchResult) {
+            return matchResult.params;
+        }
+    }
+}
+exports.MockRulesMatcher = MockRulesMatcher;

package/dist/services/rules-matchers/remote-rules-matcher.service.d.ts

@@ -0,0 +1,8 @@
+import { Config } from '../config.service';
+import { RemoteRule } from '../../types/yxorp-config';
+export declare class RemoteRulesMatcher {
+    private config;
+    constructor(config: Config);
+    match(url: string, ws?: boolean): RemoteRule | undefined;
+    toPath(url: string, remoteRule: RemoteRule): string | undefined;
+}

package/dist/services/rules-matchers/remote-rules-matcher.service.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteRulesMatcher = void 0;
+const path_to_regexp_1 = require("path-to-regexp");
+class RemoteRulesMatcher {
+    constructor(config) {
+        this.config = config;
+    }
+    match(url, ws = false) {
+        const rules = this.config.get().remoteRules || [];
+        for (let rule of rules) {
+            if (rule.disable) {
+                continue;
+            }
+            if (!!rule.ws !== ws) {
+                continue;
+            }
+            const matchResult = (0, path_to_regexp_1.match)(rule.path, {
+                decode: decodeURIComponent
+            })(url);
+            if (matchResult) {
+                return rule;
+            }
+        }
+    }
+    toPath(url, remoteRule) {
+        const matchResult = (0, path_to_regexp_1.match)(remoteRule.path, {
+            decode: decodeURIComponent
+        })(url);
+        if (matchResult) {
+            const params = matchResult.params;
+            // remoteRule.target may be a full URL (http://host:port/:param/path)
+            // Parse it and only compile the path portion
+            let baseUrl;
+            let pathPattern;
+            try {
+                const urlObj = new URL(remoteRule.target);
+                baseUrl = urlObj.origin;
+                pathPattern = urlObj.pathname;
+            }
+            catch {
+                // Not a valid URL — treat as a path pattern
+                const toPath = (0, path_to_regexp_1.compile)(remoteRule.target);
+                return toPath(matchResult.params);
+            }
+            const toPath = (0, path_to_regexp_1.compile)(pathPattern);
+            return baseUrl + toPath(params);
+        }
+    }
+}
+exports.RemoteRulesMatcher = RemoteRulesMatcher;