@plainconceptsplatform/workflows 0.4.34 → 0.5.1

package/dist/repository-inspection.d.ts

@@ -1,23 +0,0 @@
-export type RepositoryVisibility = "public" | "private";
-export type VisibilitySource = "argument" | "environment" | "github" | "fallback";
-export interface StackHints {
-    readonly packageJson: boolean;
-    readonly pnpmLockfile: boolean;
-    readonly solutionFiles: readonly string[];
-    readonly openSpec: boolean;
-}
-export interface RepositoryInspection {
-    readonly repositoryPath: string;
-    readonly existingAgentWorkflows: readonly string[];
-    readonly stackHints: StackHints;
-}
-export interface VisibilityResolution {
-    readonly value: RepositoryVisibility;
-    readonly source: VisibilitySource;
-}
-export interface CommandRunner {
-    readonly run: (command: string, arguments_: readonly string[], cwd: string) => Promise<string>;
-}
-export declare function inspectRepository(repositoryPath: string): Promise<RepositoryInspection>;
-export declare function resolveVisibility(repositoryPath: string, override: RepositoryVisibility | undefined, environment?: NodeJS.ProcessEnv, commandRunner?: CommandRunner): Promise<VisibilityResolution>;
-export declare function parseVisibility(value: string | undefined): RepositoryVisibility | undefined;

package/dist/repository-inspection.js

@@ -1,113 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { access, readdir, stat } from "node:fs/promises";
-import { constants } from "node:fs";
-import { join } from "node:path";
-const execFileAsync = promisify(execFile);
-const defaultCommandRunner = {
-    async run(command, arguments_, cwd) {
-        const { stdout } = await execFileAsync(command, arguments_, { cwd, windowsHide: true });
-        return stdout;
-    },
-};
-export async function inspectRepository(repositoryPath) {
-    const workflowsPath = join(repositoryPath, ".github", "workflows");
-    const workflowEntries = await readDirectoryNames(workflowsPath);
-    const solutionFiles = await findSolutionFiles(repositoryPath);
-    return {
-        repositoryPath,
-        existingAgentWorkflows: workflowEntries.filter((entry) => /^agent-.*\.md$/i.test(entry)).sort(),
-        stackHints: {
-            packageJson: await pathExists(join(repositoryPath, "package.json")),
-            pnpmLockfile: await pathExists(join(repositoryPath, "pnpm-lock.yaml")),
-            solutionFiles,
-            openSpec: await isDirectory(join(repositoryPath, "openspec")),
-        },
-    };
-}
-export async function resolveVisibility(repositoryPath, override, environment = process.env, commandRunner = defaultCommandRunner) {
-    if (override !== undefined)
-        return { value: override, source: "argument" };
-    const environmentOverride = parseVisibility(environment.PLATFORM_WORKFLOWS_VISIBILITY);
-    if (environmentOverride !== undefined)
-        return { value: environmentOverride, source: "environment" };
-    try {
-        const output = await commandRunner.run("gh", ["repo", "view", "--json", "visibility"], repositoryPath);
-        const visibility = parseVisibilityFromGitHub(output);
-        if (visibility !== undefined)
-            return { value: visibility, source: "github" };
-    }
-    catch {
-        // GitHub CLI is optional. Initializing a local repository must still work offline.
-    }
-    return { value: "private", source: "fallback" };
-}
-export function parseVisibility(value) {
-    return value === "public" || value === "private" ? value : undefined;
-}
-async function findSolutionFiles(repositoryPath) {
-    const results = [];
-    await scanForSlnx(repositoryPath, "", results, 0);
-    return results.sort();
-}
-const MAX_DEPTH = 5;
-const SKIP_DIRS = new Set(["node_modules", ".git", ".next", "dist", "out", "build", ".turbo", ".cache"]);
-async function scanForSlnx(root, relativePath, results, depth) {
-    if (depth >= MAX_DEPTH)
-        return;
-    const currentPath = join(root, relativePath);
-    let entries;
-    try {
-        entries = await readdir(currentPath, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        if (entry.isDirectory()) {
-            if (SKIP_DIRS.has(entry.name))
-                continue;
-            await scanForSlnx(root, join(relativePath, entry.name), results, depth + 1);
-        }
-        else if (entry.isFile() && entry.name.endsWith(".slnx")) {
-            results.push(relativePath === "" ? entry.name : join(relativePath, entry.name));
-        }
-    }
-}
-async function pathExists(path) {
-    try {
-        await access(path, constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function isDirectory(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-async function readDirectoryNames(path) {
-    try {
-        return await readdir(path);
-    }
-    catch {
-        return [];
-    }
-}
-function parseVisibilityFromGitHub(output) {
-    try {
-        const parsed = JSON.parse(output);
-        if (typeof parsed !== "object" || parsed === null || !("visibility" in parsed))
-            return undefined;
-        const { visibility } = parsed;
-        return typeof visibility === "string" ? parseVisibility(visibility.toLowerCase()) : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/repository-inspection.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/repository-inspection.test.js

@@ -1,77 +0,0 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { inspectRepository, resolveVisibility } from "./repository-inspection.js";
-import { run } from "./index.js";
-const temporaryDirectories = [];
-afterEach(async () => {
-    await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { force: true, recursive: true })));
-});
-describe("repository inspection", () => {
-    it("finds agent workflows and supported stack markers", async () => {
-        const repositoryPath = await createRepository({
-            ".github/workflows/agent-refine.md": "# Refine",
-            ".github/workflows/agent-custom.md": "# Custom",
-            ".github/workflows/other.md": "# Other",
-            "package.json": "{}",
-            "pnpm-lock.yaml": "lockfileVersion: '9.0'",
-            "apps/api/Numa.slnx": "<Solution />",
-            "openspec/changes/.gitkeep": "",
-        });
-        await expect(inspectRepository(repositoryPath)).resolves.toMatchObject({
-            existingAgentWorkflows: ["agent-custom.md", "agent-refine.md"],
-            stackHints: {
-                packageJson: true,
-                pnpmLockfile: true,
-                solutionFiles: [join("apps", "api", "Numa.slnx")],
-                openSpec: true,
-            },
-        });
-    });
-    it("uses an explicit visibility before environment or GitHub", async () => {
-        const runner = { run: async () => '{"visibility":"public"}' };
-        await expect(resolveVisibility("repo", "private", { PLATFORM_WORKFLOWS_VISIBILITY: "public" }, runner)).resolves.toEqual({
-            value: "private",
-            source: "argument",
-        });
-    });
-    it("falls back to private when GitHub CLI is unavailable", async () => {
-        const runner = { run: async () => Promise.reject(new Error("missing gh")) };
-        await expect(resolveVisibility("repo", undefined, {}, runner)).resolves.toEqual({ value: "private", source: "fallback" });
-    });
-});
-describe("CLI commands", () => {
-    it("keeps init available without writing configuration", async () => {
-        const repositoryPath = await createRepository({ "package.json": "{}" });
-        const output = captureConsole("log");
-        await expect(run(["init", "--visibility", "public"], repositoryPath)).resolves.toBe(0);
-        expect(output.calls).toHaveLength(1);
-        await expect(import("node:fs/promises").then(({ access }) => access(join(repositoryPath, ".github/workflows/shared/repo-config.md")))).rejects.toThrow();
-        output.restore();
-    });
-    it("accepts update as an add alias", async () => {
-        const repositoryPath = await createRepository({});
-        const error = captureConsole("error");
-        await expect(run(["update", "--invalid"], repositoryPath)).resolves.toBe(1);
-        expect(error.calls).toEqual(["Unknown option: --invalid"]);
-        error.restore();
-    });
-});
-function captureConsole(method) {
-    const original = console[method];
-    const calls = [];
-    console[method] = (message) => calls.push(message);
-    return { calls, restore: () => { console[method] = original; } };
-}
-async function createRepository(files) {
-    const repositoryPath = await mkdtemp(join(tmpdir(), "workflows-"));
-    temporaryDirectories.push(repositoryPath);
-    await Promise.all(Object.entries(files).map(async ([relativePath, content]) => {
-        const path = join(repositoryPath, relativePath);
-        const { mkdir } = await import("node:fs/promises");
-        await mkdir(join(path, ".."), { recursive: true });
-        await writeFile(path, content, "utf8");
-    }));
-    return repositoryPath;
-}

package/dist/repository-state.d.ts

@@ -1,18 +0,0 @@
-import type { RepositoryInspection, RepositoryVisibility, VisibilityResolution } from "./repository-inspection.js";
-export declare const manifestRelativePath = ".github/workflows/shared/platform-workflows.json";
-export declare const repositoryConfigRelativePath = ".github/workflows/shared/repo-config.md";
-export interface PlatformWorkflowsManifest {
-    readonly schemaVersion: 1;
-    readonly repositoryPath: string;
-    readonly initializedAt: string;
-    readonly visibility: RepositoryVisibility;
-    readonly visibilitySource: VisibilityResolution["source"];
-    readonly existingAgentWorkflows: readonly string[];
-    readonly stackHints: RepositoryInspection["stackHints"];
-}
-export interface InitializationResult {
-    readonly manifest: PlatformWorkflowsManifest;
-    readonly repositoryConfigCreated: boolean;
-}
-export declare function initializeRepository(inspection: RepositoryInspection, visibility: VisibilityResolution, now?: Date): Promise<InitializationResult>;
-export declare function readManifest(repositoryPath: string): Promise<PlatformWorkflowsManifest | undefined>;

package/dist/repository-state.js

@@ -1,77 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-export const manifestRelativePath = ".github/workflows/shared/platform-workflows.json";
-export const repositoryConfigRelativePath = ".github/workflows/shared/repo-config.md";
-export async function initializeRepository(inspection, visibility, now = new Date()) {
-    const configPath = join(inspection.repositoryPath, repositoryConfigRelativePath);
-    const repositoryConfigCreated = await writeRepositoryConfigIfMissing(configPath, inspection, visibility.value);
-    const manifest = {
-        schemaVersion: 1,
-        repositoryPath: inspection.repositoryPath,
-        initializedAt: now.toISOString(),
-        visibility: visibility.value,
-        visibilitySource: visibility.source,
-        existingAgentWorkflows: inspection.existingAgentWorkflows,
-        stackHints: inspection.stackHints,
-    };
-    await writeFile(join(inspection.repositoryPath, manifestRelativePath), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
-    return { manifest, repositoryConfigCreated };
-}
-export async function readManifest(repositoryPath) {
-    try {
-        const content = await readFile(join(repositoryPath, manifestRelativePath), "utf8");
-        return parseManifest(JSON.parse(content));
-    }
-    catch {
-        return undefined;
-    }
-}
-async function writeRepositoryConfigIfMissing(configPath, inspection, visibility) {
-    try {
-        await readFile(configPath, "utf8");
-        return false;
-    }
-    catch {
-        await mkdir(dirname(configPath), { recursive: true });
-        await writeFile(configPath, createRepositoryConfig(inspection, visibility), { encoding: "utf8", flag: "wx" });
-        return true;
-    }
-}
-function createRepositoryConfig(inspection, visibility) {
-    const stack = [
-        inspection.stackHints.packageJson ? "- Node.js (`package.json`)" : undefined,
-        inspection.stackHints.pnpmLockfile ? "- pnpm (`pnpm-lock.yaml`)" : undefined,
-        ...inspection.stackHints.solutionFiles.map((file) => `- .NET solution (${file})`),
-        inspection.stackHints.openSpec ? "- OpenSpec (`openspec/`)" : undefined,
-    ].filter((hint) => hint !== undefined);
-    return [
-        "# Repository workflow configuration",
-        "",
-        `- Visibility: ${visibility}`,
-        "",
-        "## Detected stack",
-        "",
-        ...(stack.length > 0 ? stack : ["- No supported stack markers detected"]),
-        "",
-        "## Verification commands",
-        "",
-        "Add repository-specific verification commands here.",
-        "",
-        "## Repository rules",
-        "",
-        "Add repository-specific workflow rules here.",
-        "",
-    ].join("\n");
-}
-function parseManifest(value) {
-    if (typeof value !== "object" || value === null)
-        return undefined;
-    const manifest = value;
-    if (manifest.schemaVersion !== 1 || typeof manifest.repositoryPath !== "string" || typeof manifest.initializedAt !== "string")
-        return undefined;
-    if (manifest.visibility !== "public" && manifest.visibility !== "private")
-        return undefined;
-    if (!Array.isArray(manifest.existingAgentWorkflows) || typeof manifest.stackHints !== "object" || manifest.stackHints === null)
-        return undefined;
-    return manifest;
-}

package/dist/repository-state.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/repository-state.test.js

@@ -1,96 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { inspectRepository, resolveVisibility } from "./repository-inspection.js";
-import { initializeRepository, manifestRelativePath, readManifest, repositoryConfigRelativePath } from "./repository-state.js";
-import { run } from "./index.js";
-const temporaryDirectories = [];
-afterEach(async () => {
-    await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { force: true, recursive: true })));
-});
-describe("repository inspection", () => {
-    it("finds agent workflows and supported stack markers", async () => {
-        const repositoryPath = await createRepository({
-            ".github/workflows/agent-refine.md": "# Refine",
-            ".github/workflows/agent-custom.md": "# Custom",
-            ".github/workflows/other.md": "# Other",
-            "package.json": "{}",
-            "pnpm-lock.yaml": "lockfileVersion: '9.0'",
-            "apps/api/Numa.slnx": "<Solution />",
-            "openspec/changes/.gitkeep": "",
-        });
-        await expect(inspectRepository(repositoryPath)).resolves.toMatchObject({
-            existingAgentWorkflows: ["agent-custom.md", "agent-refine.md"],
-            stackHints: {
-                packageJson: true,
-                pnpmLockfile: true,
-                solutionFiles: [join(repositoryPath, "apps", "api", "Numa.slnx")],
-                openSpec: true,
-            },
-        });
-    });
-    it("uses an explicit visibility before environment or GitHub", async () => {
-        const runner = { run: async () => '{"visibility":"public"}' };
-        await expect(resolveVisibility("repo", "private", { PLATFORM_WORKFLOWS_VISIBILITY: "public" }, runner)).resolves.toEqual({
-            value: "private",
-            source: "argument",
-        });
-    });
-    it("falls back to private when GitHub CLI is unavailable", async () => {
-        const runner = { run: async () => Promise.reject(new Error("missing gh")) };
-        await expect(resolveVisibility("repo", undefined, {}, runner)).resolves.toEqual({ value: "private", source: "fallback" });
-    });
-});
-describe("repository initialization", () => {
-    it("creates config once and updates the managed manifest", async () => {
-        const repositoryPath = await createRepository({ "package.json": "{}" });
-        const inspection = await inspectRepository(repositoryPath);
-        const first = await initializeRepository(inspection, { value: "public", source: "argument" }, new Date("2026-08-12T00:00:00.000Z"));
-        const configPath = join(repositoryPath, repositoryConfigRelativePath);
-        await writeFile(configPath, "consumer settings\n", "utf8");
-        const second = await initializeRepository(inspection, { value: "private", source: "fallback" }, new Date("2026-08-13T00:00:00.000Z"));
-        expect(first.repositoryConfigCreated).toBe(true);
-        expect(second.repositoryConfigCreated).toBe(false);
-        await expect(readFile(configPath, "utf8")).resolves.toBe("consumer settings\n");
-        await expect(readManifest(repositoryPath)).resolves.toMatchObject({
-            initializedAt: "2026-08-13T00:00:00.000Z",
-            visibility: "private",
-            visibilitySource: "fallback",
-        });
-        await expect(readFile(join(repositoryPath, manifestRelativePath), "utf8")).resolves.toContain('"schemaVersion": 1');
-    });
-});
-describe("CLI commands", () => {
-    it("keeps init available", async () => {
-        const repositoryPath = await createRepository({ "package.json": "{}" });
-        const output = captureConsole("log");
-        await expect(run(["init", "--visibility", "public"], repositoryPath)).resolves.toBe(0);
-        expect(output.calls).toHaveLength(1);
-        output.restore();
-    });
-    it("accepts update as an add alias", async () => {
-        const repositoryPath = await createRepository({});
-        const error = captureConsole("error");
-        await expect(run(["update", "--invalid"], repositoryPath)).resolves.toBe(1);
-        expect(error.calls).toEqual(["update accepts only --force."]);
-        error.restore();
-    });
-});
-function captureConsole(method) {
-    const original = console[method];
-    const calls = [];
-    console[method] = (message) => calls.push(message);
-    return { calls, restore: () => { console[method] = original; } };
-}
-async function createRepository(files) {
-    const repositoryPath = await mkdtemp(join(tmpdir(), "platform-workflows-"));
-    temporaryDirectories.push(repositoryPath);
-    await Promise.all(Object.entries(files).map(async ([relativePath, content]) => {
-        const path = join(repositoryPath, relativePath);
-        const { mkdir } = await import("node:fs/promises");
-        await mkdir(join(path, ".."), { recursive: true });
-        await writeFile(path, content, "utf8");
-    }));
-    return repositoryPath;
-}

package/dist/route-processing.d.ts

@@ -1,6 +0,0 @@
-import { type RouteName } from "./workflow-catalog.js";
-export declare function stripRouteFromRouter(yaml: string, route: RouteName): string;
-export declare function stripRouteFromClassifier(shell: string, route: RouteName): string;
-export declare function addRouteExclusion(matrix: string, route: RouteName): string;
-export declare function processRoutes(files: Map<string, string>, selectedRoutes: readonly RouteName[]): Map<string, string>;
-export declare function excludedWorkerFiles(selectedRoutes: readonly RouteName[]): Set<string>;

package/dist/route-processing.js

@@ -1,150 +0,0 @@
-import { routeNames, workflowRoutes } from "./workflow-catalog.js";
-const routeCrons = {
-    audit: "17 1 * * 1",
-    propose: "29 7 * * *",
-};
-export function stripRouteFromRouter(yaml, route) {
-    let result = yaml;
-    const cron = routeCrons[route];
-    if (cron !== undefined) {
-        result = result.replace(new RegExp(`^    - cron: "${escapeRegex(cron)}"\\n`, "gm"), "");
-    }
-    result = removeJobBlock(result, `call-${route}`);
-    result = result.replace(new RegExp(`^          - ${escapeRegex(route)}\\n`, "gm"), "");
-    return result;
-}
-export function stripRouteFromClassifier(shell, route) {
-    const constName = route.replace(/-/g, "_").toUpperCase() + "_CRON";
-    let result = shell;
-    result = result.replace(new RegExp(`^readonly ${constName}="[^"]*"\\n`, "gm"), "");
-    const cron = routeCrons[route];
-    if (cron !== undefined) {
-        result = result.replace(new RegExp(`\\s*"\\$${constName}"\\) route="${escapeRegex(route)}" ;;\\n`, "g"), "");
-    }
-    result = result.replace(new RegExp(` \\| ${escapeRegex(route)}\\)`, "g"), ")");
-    result = result.replace(new RegExp(`^(\\s+)${escapeRegex(route)} \\| `, "gm"), "$1");
-    if (!result.includes(`| ${route}`) && !result.includes(`${route} |`)) {
-        result = removeAloneDispatchCase(result, route);
-    }
-    return result;
-}
-function removeAloneDispatchCase(shell, route) {
-    const lines = shell.split("\n");
-    const pattern = new RegExp(`^(\\s+)${escapeRegex(route)}\\)\\s*$`);
-    const result = [];
-    let i = 0;
-    while (i < lines.length) {
-        const match = lines[i].match(pattern);
-        if (match) {
-            const indent = match[1];
-            i++;
-            while (i < lines.length) {
-                if (new RegExp(`^${escapeRegex(indent)};;\\s*$`).test(lines[i])) {
-                    i++;
-                    break;
-                }
-                i++;
-            }
-        }
-        else {
-            result.push(lines[i]);
-            i++;
-        }
-    }
-    return result.join("\n");
-}
-export function addRouteExclusion(matrix, route) {
-    if (matrix.includes(`excluded route '${route}'`))
-        return matrix;
-    let result = matrix;
-    result = result.replace(new RegExp(` ${escapeRegex(route)} `, "g"), " ");
-    const exclusionBlock = `\necho "── Excluded routes ──────────────────────────────────────────────────────"\nif ! grep -q "route == '${route}'" "$ROUTER_YML"; then\n  PASS=$((PASS + 1))\n  echo "  ${route} correctly excluded from work-router.yml"\nelse\n  FAIL=$((FAIL + 1))\n  echo "FAIL: excluded route '${route}' is still in work-router.yml" >&2\nfi\n`;
-    result = result.replace(/(\necho\nif \[ "\$FAIL" -eq 0 \])/, `${exclusionBlock}$1`);
-    return result;
-}
-export function processRoutes(files, selectedRoutes) {
-    const excludedRoutes = routeNames.filter((r) => !selectedRoutes.includes(r));
-    if (excludedRoutes.length === 0)
-        return files;
-    const result = new Map(files);
-    for (const route of excludedRoutes) {
-        const routerKey = findFileKey(result, "work-router.yml");
-        if (routerKey !== undefined) {
-            result.set(routerKey, stripRouteFromRouter(result.get(routerKey), route));
-        }
-        const matrixKey = findFileKey(result, "verify-route-matrix.sh");
-        if (matrixKey !== undefined) {
-            result.set(matrixKey, addRouteExclusion(result.get(matrixKey), route));
-        }
-    }
-    const matrixKey = findFileKey(result, "verify-route-matrix.sh");
-    if (matrixKey !== undefined) {
-        result.set(matrixKey, createRouteMatrix(selectedRoutes));
-    }
-    return result;
-}
-function createRouteMatrix(selectedRoutes) {
-    const selected = selectedRoutes.join(" ");
-    const excluded = routeNames.filter((route) => !selectedRoutes.includes(route)).join(" ");
-    return `#!/usr/bin/env bash
-set -euo pipefail
-
-HERE="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
-ROUTER_YML="\${HERE}/../../workflows/work-router.yml"
-CLASSIFIER="\${HERE}/../classify-route/classify-route.sh"
-
-bash -n "$CLASSIFIER"
-
-for route in ${selected}; do
-  grep -q "route == '$route'" "$ROUTER_YML" || {
-    echo "FAIL: selected route '$route' has no router job" >&2
-    exit 1
-  }
-done
-
-for route in ${excluded}; do
-  if grep -q "route == '$route'" "$ROUTER_YML"; then
-    echo "FAIL: excluded route '$route' remains in router" >&2
-    exit 1
-  fi
-done
-
-echo "Route matrix: selected routes valid"
-`;
-}
-export function excludedWorkerFiles(selectedRoutes) {
-    return new Set(workflowRoutes
-        .filter((route) => !selectedRoutes.includes(route.name))
-        .map((route) => route.worker));
-}
-function removeJobBlock(yaml, jobName) {
-    const lines = yaml.split("\n");
-    const startPattern = new RegExp(`^  ${escapeRegex(jobName)}:`);
-    const result = [];
-    let skipping = false;
-    for (const line of lines) {
-        if (skipping) {
-            if (/^  \S/.test(line) || /^[^\s]/.test(line)) {
-                skipping = false;
-                result.push(line);
-            }
-        }
-        else if (startPattern.test(line)) {
-            skipping = true;
-        }
-        else {
-            result.push(line);
-        }
-    }
-    return result.join("\n");
-}
-function findFileKey(files, endsWith) {
-    for (const key of files.keys()) {
-        if (key.endsWith(endsWith))
-            return key;
-    }
-    return undefined;
-}
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/dist/route-processing.test.d.ts

@@ -1 +0,0 @@
-export {};