@principal-ai/logo-component 0.1.5 → 0.1.6

package/dist/MazeDemo.js

@@ -1,376 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MazeDemo = void 0;
-const react_1 = __importStar(require("react"));
-const mazeGenerator_1 = require("./utils/mazeGenerator");
-const MazeDemo = ({ width = 450, height = 620, mazeColor = "#6366f1", errorColor = "#ef4444", searchColor = "#f59e0b", solutionColor = "#10b981", mazeSeed = 42, }) => {
-    // Maze configuration
-    const gridSize = 10;
-    const cellSize = 30;
-    const padding = 50;
-    const mazeWidth = gridSize * cellSize;
-    const mazeHeight = gridSize * cellSize;
-    const mazeX = (width - mazeWidth) / 2;
-    // Key positions
-    const startCol = 0;
-    const startRow = 0;
-    const destCol = 9;
-    const destRow = 9;
-    // State
-    const [revealedCells, setRevealedCells] = (0, react_1.useState)([]);
-    const [directionHint, setDirectionHint] = (0, react_1.useState)("");
-    const [timeCost, setTimeCost] = (0, react_1.useState)(0);
-    const [clickCost, setClickCost] = (0, react_1.useState)(0);
-    const [blockageFound, setBlockageFound] = (0, react_1.useState)(false);
-    const [startTime, setStartTime] = (0, react_1.useState)(null);
-    const [started, setStarted] = (0, react_1.useState)(false);
-    const [currentSeed, setCurrentSeed] = (0, react_1.useState)(() => Math.floor(Math.random() * 10000));
-    const [blockageInjected, setBlockageInjected] = (0, react_1.useState)(false);
-    const [deployed, setDeployed] = (0, react_1.useState)(false);
-    const [mode, setMode] = (0, react_1.useState)('initial');
-    // Total incident cost
-    const incidentCost = timeCost + clickCost;
-    // Update currentSeed when mazeSeed prop changes
-    (0, react_1.useEffect)(() => {
-        setCurrentSeed(mazeSeed);
-    }, [mazeSeed]);
-    // Increment time cost
-    (0, react_1.useEffect)(() => {
-        if (blockageFound || !startTime || !started)
-            return;
-        const interval = setInterval(() => {
-            setTimeCost(prev => prev + 1);
-        }, 10);
-        return () => clearInterval(interval);
-    }, [blockageFound, startTime, started]);
-    // Generate maze
-    const { horizontalWalls, verticalWalls, blockageWall, actualBlockageCol, actualBlockageRow } = (0, react_1.useMemo)(() => {
-        let seed = currentSeed;
-        const seededRandom = () => {
-            seed = (seed * 9301 + 49297) % 233280;
-            return seed / 233280;
-        };
-        const originalRandom = Math.random;
-        Math.random = seededRandom;
-        const generator = new mazeGenerator_1.MazeGenerator(gridSize, gridSize);
-        generator.generate(startRow, startCol);
-        let blockCell = { row: 5, col: 5 };
-        let direction = 'east';
-        let blockageWall = null;
-        if (blockageInjected) {
-            const path = generator.findPath(startRow, startCol, destRow, destCol);
-            if (path.length > 2) {
-                const middleStart = Math.floor(path.length * 0.3);
-                const middleEnd = Math.floor(path.length * 0.7);
-                const blockIndex = Math.floor(seededRandom() * (middleEnd - middleStart)) + middleStart;
-                blockCell = path[blockIndex];
-                if (blockIndex < path.length - 1) {
-                    const nextCell = path[blockIndex + 1];
-                    const rowDiff = nextCell.row - blockCell.row;
-                    const colDiff = nextCell.col - blockCell.col;
-                    if (rowDiff === 1)
-                        direction = 'south';
-                    else if (rowDiff === -1)
-                        direction = 'north';
-                    else if (colDiff === 1)
-                        direction = 'east';
-                    else if (colDiff === -1)
-                        direction = 'west';
-                }
-            }
-            generator.addBlockage(blockCell.row, blockCell.col, direction);
-        }
-        const walls = generator.getWalls();
-        if (blockageInjected) {
-            if (direction === 'east' || direction === 'west') {
-                const targetCol = direction === 'east' ? blockCell.col + 1 : blockCell.col;
-                const targetRow = blockCell.row;
-                const wallSegment = walls.vertical.find(wall => {
-                    const [col, row1, , row2] = wall;
-                    return col === targetCol && row1 <= targetRow && row2 > targetRow;
-                });
-                if (wallSegment) {
-                    const [col, row1, , row2] = wallSegment;
-                    blockageWall = { type: 'vertical', col, row1, row2 };
-                }
-            }
-            else {
-                const targetRow = direction === 'south' ? blockCell.row + 1 : blockCell.row;
-                const targetCol = blockCell.col;
-                const wallSegment = walls.horizontal.find(wall => {
-                    const [col1, row, col2] = wall;
-                    return row === targetRow && col1 <= targetCol && col2 > targetCol;
-                });
-                if (wallSegment) {
-                    const [col1, row, col2] = wallSegment;
-                    blockageWall = { type: 'horizontal', row, col1, col2 };
-                }
-            }
-        }
-        Math.random = originalRandom;
-        return {
-            horizontalWalls: walls.horizontal,
-            verticalWalls: walls.vertical,
-            blockageWall,
-            actualBlockageCol: blockCell.col,
-            actualBlockageRow: blockCell.row,
-        };
-    }, [currentSeed, blockageInjected]);
-    // Handlers
-    const handleModeSelect = (selectedMode) => {
-        setMode(selectedMode);
-    };
-    const handleDeploy = () => {
-        setDeployed(true);
-        setTimeout(() => {
-            setBlockageInjected(true);
-            setStarted(true);
-            setStartTime(Date.now());
-        }, 3000);
-    };
-    const handleTryPrincipal = () => {
-        setMode('principal');
-        setRevealedCells([]);
-        setDirectionHint("");
-        setBlockageFound(false);
-        setTimeCost(0);
-        setClickCost(0);
-        setStartTime(null);
-        setStarted(false);
-        setDeployed(false);
-        setBlockageInjected(false); // Principal mode still needs to deploy first
-    };
-    const handleTryAgain = () => {
-        setRevealedCells([]);
-        setDirectionHint("");
-        setBlockageFound(false);
-        setTimeCost(0);
-        setClickCost(0);
-        setStartTime(null);
-        setStarted(false);
-        setBlockageInjected(false);
-        setDeployed(false);
-        setMode('initial');
-        setCurrentSeed(Math.floor(Math.random() * 10000));
-    };
-    const handleCellClick = (col, row) => {
-        if (blockageFound || !started)
-            return;
-        // In principal mode, only allow clicking the blockage cell
-        if (mode === 'principal') {
-            const isBlockageCell = col === actualBlockageCol && row === actualBlockageRow;
-            if (isBlockageCell) {
-                setDirectionHint("🎯 Blockage Found!");
-                setBlockageFound(true);
-            }
-            return;
-        }
-        const alreadyRevealed = revealedCells.some(cell => cell.col === col && cell.row === row);
-        if (alreadyRevealed)
-            return;
-        setClickCost(prev => prev + 500);
-        setRevealedCells([...revealedCells, { col, row }]);
-        const isBlockageCell = col === actualBlockageCol && row === actualBlockageRow;
-        if (isBlockageCell) {
-            setDirectionHint("🎯 Blockage Found!");
-            setBlockageFound(true);
-            const cellsToReveal = [...revealedCells];
-            for (let r = 0; r < gridSize; r++) {
-                for (let c = 0; c < gridSize; c++) {
-                    const distance = Math.abs(actualBlockageCol - c) + Math.abs(actualBlockageRow - r);
-                    if (distance <= 3) {
-                        const alreadyInList = cellsToReveal.some(cell => cell.col === c && cell.row === r);
-                        if (!alreadyInList) {
-                            cellsToReveal.push({ col: c, row: r });
-                        }
-                    }
-                }
-            }
-            setRevealedCells(cellsToReveal);
-        }
-        else {
-            const colDiff = actualBlockageCol - col;
-            const rowDiff = actualBlockageRow - row;
-            let direction = "";
-            if (Math.abs(rowDiff) > 1) {
-                direction += rowDiff > 0 ? "↓ " : "↑ ";
-            }
-            if (Math.abs(colDiff) > 1) {
-                direction += colDiff > 0 ? "→" : "←";
-            }
-            const distance = Math.abs(colDiff) + Math.abs(rowDiff);
-            let proximity = "";
-            if (distance <= 2)
-                proximity = "Very close!";
-            else if (distance <= 4)
-                proximity = "Getting warmer...";
-            else if (distance <= 6)
-                proximity = "Still far...";
-            else
-                proximity = "Cold...";
-            setDirectionHint(`${direction} ${proximity}`);
-        }
-    };
-    // Render maze
-    const renderMaze = (showBlockage, opacity = 1) => {
-        const elements = [];
-        elements.push(react_1.default.createElement("rect", { key: "background", x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "none", stroke: mazeColor, strokeWidth: "3", opacity: 0.3 * opacity }));
-        const isBlockageWall = (type, wall) => {
-            if (!showBlockage || !blockageWall)
-                return false;
-            if (type === 'vertical') {
-                const [x, y1, , y2] = wall;
-                return (blockageWall.type === 'vertical' &&
-                    x === blockageWall.col &&
-                    y1 === blockageWall.row1 &&
-                    y2 === blockageWall.row2);
-            }
-            else if (type === 'horizontal') {
-                const [x1, y, x2] = wall;
-                return (blockageWall.type === 'horizontal' &&
-                    y === blockageWall.row &&
-                    x1 === blockageWall.col1 &&
-                    x2 === blockageWall.col2);
-            }
-            return false;
-        };
-        horizontalWalls.forEach((wall, idx) => {
-            const [x1, y, x2] = wall;
-            const isBlockage = isBlockageWall('horizontal', wall);
-            elements.push(react_1.default.createElement("line", { key: `h-wall-${idx}`, x1: mazeX + x1 * cellSize, y1: padding + y * cellSize, x2: mazeX + x2 * cellSize, y2: padding + y * cellSize, stroke: isBlockage ? errorColor : mazeColor, strokeWidth: isBlockage ? 4 : 2.5, strokeLinecap: "round", opacity: opacity }, isBlockage && showBlockage && (react_1.default.createElement("animate", { attributeName: "stroke-width", values: "4;6;4", dur: "1.5s", repeatCount: "indefinite" }))));
-        });
-        verticalWalls.forEach((wall, idx) => {
-            const [x, y1, , y2] = wall;
-            const isBlockage = isBlockageWall('vertical', wall);
-            elements.push(react_1.default.createElement("line", { key: `v-wall-${idx}`, x1: mazeX + x * cellSize, y1: padding + y1 * cellSize, x2: mazeX + x * cellSize, y2: padding + y2 * cellSize, stroke: isBlockage ? errorColor : mazeColor, strokeWidth: isBlockage ? 4 : 2.5, strokeLinecap: "round", opacity: opacity }, isBlockage && showBlockage && (react_1.default.createElement("animate", { attributeName: "stroke-width", values: "4;6;4", dur: "1.5s", repeatCount: "indefinite" }))));
-        });
-        for (let row = 0; row <= gridSize; row++) {
-            elements.push(react_1.default.createElement("line", { key: `grid-h-${row}`, x1: mazeX, y1: padding + row * cellSize, x2: mazeX + mazeWidth, y2: padding + row * cellSize, stroke: mazeColor, strokeWidth: "0.5", opacity: 0.15 * opacity }));
-        }
-        for (let col = 0; col <= gridSize; col++) {
-            elements.push(react_1.default.createElement("line", { key: `grid-v-${col}`, x1: mazeX + col * cellSize, y1: padding, x2: mazeX + col * cellSize, y2: padding + mazeHeight, stroke: mazeColor, strokeWidth: "0.5", opacity: 0.15 * opacity }));
-        }
-        return elements;
-    };
-    const getTitle = () => {
-        if (mode === 'principal')
-            return "With Principal";
-        if (mode === 'agentic')
-            return "With Agentic Coding";
-        if (mode === 'no-agentic')
-            return "Without Agentic Coding";
-        return "Choose Your Approach";
-    };
-    const getSubtitle = () => {
-        if (mode === 'principal')
-            return "Full visibility - See everything";
-        if (started)
-            return "Find the blockage";
-        if (deployed)
-            return "Running smoothly...";
-        return "How will you handle production?";
-    };
-    const showCover = mode === 'agentic' || (deployed && mode === 'no-agentic');
-    const coverOpacity = 1; // Always full opacity for the cover
-    const mazeOpacity = 1; // Maze always at full opacity, cover handles visibility
-    return (react_1.default.createElement("svg", { width: width, height: height, xmlns: "http://www.w3.org/2000/svg" },
-        react_1.default.createElement("text", { x: width / 2, y: 25, textAnchor: "middle", fill: mazeColor, fontSize: "16", fontWeight: "bold" }, getTitle()),
-        react_1.default.createElement("text", { x: width / 2, y: 40, textAnchor: "middle", fill: mazeColor, fontSize: "11", opacity: "0.6" }, getSubtitle()),
-        mode !== 'initial' && (react_1.default.createElement(react_1.default.Fragment, null,
-            react_1.default.createElement("g", null, renderMaze(mode === 'principal' || blockageFound, mazeOpacity)),
-            react_1.default.createElement("circle", { cx: mazeX + (startCol + 0.5) * cellSize, cy: padding + (startRow + 0.5) * cellSize, r: "5", fill: searchColor }),
-            react_1.default.createElement("text", { x: mazeX - 5, y: padding - 5, textAnchor: "end", fontSize: "10", fill: searchColor, fontWeight: "bold" }, "START"),
-            react_1.default.createElement("g", null,
-                react_1.default.createElement("circle", { cx: mazeX + (destCol + 0.5) * cellSize, cy: padding + (destRow + 0.5) * cellSize, r: "8", fill: "none", stroke: mazeColor, strokeWidth: "1.5", opacity: "0.5" }),
-                react_1.default.createElement("circle", { cx: mazeX + (destCol + 0.5) * cellSize, cy: padding + (destRow + 0.5) * cellSize, r: "5", fill: "none", stroke: mazeColor, strokeWidth: "1.5", opacity: "0.6" }),
-                react_1.default.createElement("circle", { cx: mazeX + (destCol + 0.5) * cellSize, cy: padding + (destRow + 0.5) * cellSize, r: "2", fill: mazeColor, opacity: "0.7" })),
-            react_1.default.createElement("text", { x: mazeX + mazeWidth + 5, y: padding + mazeHeight + 15, textAnchor: "start", fontSize: "9", fill: mazeColor, fontWeight: "bold" }, "DEST"))),
-        showCover && (react_1.default.createElement(react_1.default.Fragment, null,
-            react_1.default.createElement("defs", null,
-                react_1.default.createElement("mask", { id: "mazeCoverMask" },
-                    react_1.default.createElement("rect", { x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "white" }),
-                    revealedCells.map((cell, idx) => (react_1.default.createElement("rect", { key: idx, x: mazeX + cell.col * cellSize, y: padding + cell.row * cellSize, width: cellSize, height: cellSize, fill: "black" }))))),
-            react_1.default.createElement("g", null,
-                react_1.default.createElement("rect", { x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "#2a2a2a", opacity: coverOpacity, mask: "url(#mazeCoverMask)" }),
-                react_1.default.createElement("rect", { x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "none", stroke: mazeColor, strokeWidth: "3", opacity: "0.4" }),
-                started && revealedCells.length === 0 && (react_1.default.createElement("g", null,
-                    react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 - 130, y: padding + mazeHeight / 2 - 40, width: 260, height: 80, fill: "#000000", opacity: "0.7", rx: "8", pointerEvents: "none" }),
-                    react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight / 2 - 15, textAnchor: "middle", fontSize: "18", fill: errorColor, fontWeight: "bold", pointerEvents: "none" }, "\uD83D\uDEA8 INCIDENT ALERT"),
-                    react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight / 2 + 10, textAnchor: "middle", fontSize: "13", fill: "#ffffff", fontWeight: "normal", pointerEvents: "none" }, "It's 3:00 AM - Find the blockage!"))),
-                started && revealedCells.length > 0 && directionHint && (react_1.default.createElement("g", null,
-                    react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 - 100, y: padding + mazeHeight / 2 - 25, width: 200, height: 40, fill: "#000000", opacity: "0.7", rx: "6", pointerEvents: "none" }),
-                    react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight / 2, textAnchor: "middle", fontSize: "16", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, directionHint)))))),
-        started && (react_1.default.createElement("g", null, Array.from({ length: gridSize }).map((_, row) => Array.from({ length: gridSize }).map((_, col) => (react_1.default.createElement("rect", { key: `cell-${row}-${col}`, x: mazeX + col * cellSize, y: padding + row * cellSize, width: cellSize, height: cellSize, fill: "transparent", stroke: "none", style: { cursor: 'pointer' }, onClick: () => handleCellClick(col, row), onMouseEnter: (e) => {
-                e.currentTarget.setAttribute('fill', searchColor);
-                e.currentTarget.setAttribute('opacity', '0.1');
-            }, onMouseLeave: (e) => {
-                e.currentTarget.setAttribute('fill', 'transparent');
-                e.currentTarget.setAttribute('opacity', '1');
-            } })))))),
-        mode === 'initial' && (react_1.default.createElement("g", null,
-            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: () => handleModeSelect('no-agentic') },
-                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 - 130, y: padding + mazeHeight + 25, width: 120, height: 40, fill: searchColor, rx: "6" }),
-                react_1.default.createElement("text", { x: mazeX + mazeWidth / 2 - 70, y: padding + mazeHeight + 52, textAnchor: "middle", fontSize: "12", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, "No Agentic")),
-            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: () => handleModeSelect('agentic') },
-                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 + 10, y: padding + mazeHeight + 25, width: 120, height: 40, fill: mazeColor, rx: "6" }),
-                react_1.default.createElement("text", { x: mazeX + mazeWidth / 2 + 70, y: padding + mazeHeight + 52, textAnchor: "middle", fontSize: "12", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, "Agentic Coding")))),
-        (mode === 'no-agentic' || mode === 'agentic' || mode === 'principal') && !deployed && (react_1.default.createElement("g", null,
-            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: handleDeploy },
-                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 - 60, y: padding + mazeHeight + 25, width: 120, height: 40, fill: searchColor, rx: "6" }),
-                react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 52, textAnchor: "middle", fontSize: "16", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, "DEPLOY")))),
-        deployed && !started && (react_1.default.createElement("g", null,
-            react_1.default.createElement("rect", { x: mazeX, y: padding + mazeHeight + 20, width: mazeWidth, height: 35, fill: solutionColor, opacity: "0.9", rx: "4" }),
-            react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 35, textAnchor: "middle", fontSize: "11", fill: "#ffffff", fontWeight: "normal" }, "\u2713 Deployment Successful"),
-            react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 50, textAnchor: "middle", fontSize: "14", fill: "#ffffff", fontWeight: "bold" }, "All systems operational"))),
-        started && (react_1.default.createElement("g", null,
-            react_1.default.createElement("rect", { x: mazeX, y: padding + mazeHeight + 20, width: mazeWidth, height: 35, fill: blockageFound ? solutionColor : errorColor, opacity: "0.9", rx: "4" }),
-            react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 35, textAnchor: "middle", fontSize: "11", fill: "#ffffff", fontWeight: "normal" }, blockageFound ? "Incident Resolved!" : "Incident Cost"),
-            react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 50, textAnchor: "middle", fontSize: "18", fill: "#ffffff", fontWeight: "bold" },
-                "$",
-                incidentCost.toLocaleString()))),
-        started && blockageFound && mode !== 'principal' && (react_1.default.createElement("g", null,
-            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: handleTryAgain },
-                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 - 130, y: padding + mazeHeight + 65, width: 120, height: 25, fill: mazeColor, opacity: "0.2", rx: "4" }),
-                react_1.default.createElement("text", { x: mazeX + mazeWidth / 2 - 70, y: padding + mazeHeight + 82, textAnchor: "middle", fontSize: "10", fill: mazeColor, fontWeight: "bold", pointerEvents: "none" }, "Try Again")),
-            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: handleTryPrincipal },
-                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 + 10, y: padding + mazeHeight + 65, width: 120, height: 25, fill: solutionColor, opacity: "0.8", rx: "4" }),
-                react_1.default.createElement("text", { x: mazeX + mazeWidth / 2 + 70, y: padding + mazeHeight + 82, textAnchor: "middle", fontSize: "10", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, "Try with Principal")))),
-        mode === 'principal' && blockageFound && (react_1.default.createElement("g", null,
-            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: handleTryAgain },
-                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 - 60, y: padding + mazeHeight + 65, width: 120, height: 25, fill: mazeColor, opacity: "0.3", rx: "4" }),
-                react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 82, textAnchor: "middle", fontSize: "10", fill: mazeColor, fontWeight: "bold", pointerEvents: "none" }, "Try Again"))))));
-};
-exports.MazeDemo = MazeDemo;

package/dist/MazeDemoNew.d.ts

@@ -1,12 +0,0 @@
-import React from "react";
-interface MazeDemoProps {
-    width?: number;
-    height?: number;
-    mazeColor?: string;
-    errorColor?: string;
-    searchColor?: string;
-    solutionColor?: string;
-    mazeSeed?: number;
-}
-export declare const MazeDemoNew: React.FC<MazeDemoProps>;
-export {};