From 2c3174eb0b26f3d8d345b5f460d453779f47d09f Mon Sep 17 00:00:00 2001 From: dj-oyu <68707227+dj-oyu@users.noreply.github.com> Date: Sun, 15 Mar 2026 16:00:15 +0900 Subject: [PATCH] feat: use marked + highlight.js for markdown in Mini App Replace hand-rolled renderSimpleMarkdown() with marked (GFM) and highlight.js (11 languages). Research documents and memory view now render headings, code blocks with syntax highlighting, tables, links, and inline formatting. Co-Authored-By: Claude Opus 4.6 (1M context) --- pkg/miniapp/frontend/bun.lock | 208 + pkg/miniapp/frontend/package.json | 5 +- pkg/miniapp/frontend/src/app.js | 80 +- pkg/miniapp/frontend/src/styles.css | 64 + pkg/miniapp/static/dist/app.css | 187 + pkg/miniapp/static/dist/app.js | 7223 ++++++++++++++++++++++++++- 6 files changed, 7700 insertions(+), 67 deletions(-) create mode 100644 pkg/miniapp/frontend/bun.lock diff --git a/pkg/miniapp/frontend/bun.lock b/pkg/miniapp/frontend/bun.lock new file mode 100644 index 000000000..b8130a079 --- /dev/null +++ b/pkg/miniapp/frontend/bun.lock @@ -0,0 +1,208 @@ +{ + "lockfileVersion": 1, + "configVersion": 1, + "workspaces": { + "": { + "name": "miniapp-frontend", + "dependencies": { + "highlight.js": "^11.11.1", + "marked": "^17.0.4", + }, + "devDependencies": { + "happy-dom": "^16.8.1", + "vitest": "^2.1.9", + }, + }, + }, + "packages": { + "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.21.5", "", { "os": "aix", "cpu": "ppc64" }, "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ=="], + + "@esbuild/android-arm": ["@esbuild/android-arm@0.21.5", "", { "os": "android", "cpu": "arm" }, "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg=="], + + "@esbuild/android-arm64": ["@esbuild/android-arm64@0.21.5", "", { "os": "android", "cpu": "arm64" }, "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A=="], + + "@esbuild/android-x64": ["@esbuild/android-x64@0.21.5", "", { "os": "android", "cpu": "x64" }, "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA=="], + + "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.21.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ=="], + + "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.21.5", "", { "os": "darwin", "cpu": "x64" }, "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw=="], + + "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.21.5", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g=="], + + "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.21.5", "", { "os": "freebsd", "cpu": "x64" }, "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ=="], + + "@esbuild/linux-arm": ["@esbuild/linux-arm@0.21.5", "", { "os": "linux", "cpu": "arm" }, "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA=="], + + "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.21.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q=="], + + "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.21.5", "", { "os": "linux", "cpu": "ia32" }, "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg=="], + + "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.21.5", "", { "os": "linux", "cpu": "none" }, "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg=="], + + "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.21.5", "", { "os": "linux", "cpu": "none" }, "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg=="], + + "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.21.5", "", { "os": "linux", "cpu": "ppc64" }, "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w=="], + + "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.21.5", "", { "os": "linux", "cpu": "none" }, "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA=="], + + "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.21.5", "", { "os": "linux", "cpu": "s390x" }, "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A=="], + + "@esbuild/linux-x64": ["@esbuild/linux-x64@0.21.5", "", { "os": "linux", "cpu": "x64" }, "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ=="], + + "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.21.5", "", { "os": "none", "cpu": "x64" }, "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg=="], + + "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.21.5", "", { "os": "openbsd", "cpu": "x64" }, "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow=="], + + "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.21.5", "", { "os": "sunos", "cpu": "x64" }, "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg=="], + + "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.21.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A=="], + + "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.21.5", "", { "os": "win32", "cpu": "ia32" }, "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA=="], + + "@esbuild/win32-x64": ["@esbuild/win32-x64@0.21.5", "", { "os": "win32", "cpu": "x64" }, "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw=="], + + "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="], + + "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.59.0", "", { "os": "android", "cpu": "arm" }, "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg=="], + + "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.59.0", "", { "os": "android", "cpu": "arm64" }, "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q=="], + + "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.59.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg=="], + + "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.59.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w=="], + + "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.59.0", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA=="], + + "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.59.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg=="], + + "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.59.0", "", { "os": "linux", "cpu": "arm" }, "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw=="], + + "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.59.0", "", { "os": "linux", "cpu": "arm" }, "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA=="], + + "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.59.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA=="], + + "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.59.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA=="], + + "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg=="], + + "@rollup/rollup-linux-loong64-musl": ["@rollup/rollup-linux-loong64-musl@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q=="], + + "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.59.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA=="], + + "@rollup/rollup-linux-ppc64-musl": ["@rollup/rollup-linux-ppc64-musl@4.59.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA=="], + + "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg=="], + + "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg=="], + + "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.59.0", "", { "os": "linux", "cpu": "s390x" }, "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w=="], + + "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.59.0", "", { "os": "linux", "cpu": "x64" }, "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg=="], + + "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.59.0", "", { "os": "linux", "cpu": "x64" }, "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg=="], + + "@rollup/rollup-openbsd-x64": ["@rollup/rollup-openbsd-x64@4.59.0", "", { "os": "openbsd", "cpu": "x64" }, "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ=="], + + "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.59.0", "", { "os": "none", "cpu": "arm64" }, "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA=="], + + "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.59.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A=="], + + "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.59.0", "", { "os": "win32", "cpu": "ia32" }, "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA=="], + + "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.59.0", "", { "os": "win32", "cpu": "x64" }, "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA=="], + + "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.59.0", "", { "os": "win32", "cpu": "x64" }, "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA=="], + + "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="], + + "@vitest/expect": ["@vitest/expect@2.1.9", "", { "dependencies": { "@vitest/spy": "2.1.9", "@vitest/utils": "2.1.9", "chai": "5.3.3", "tinyrainbow": "1.2.0" } }, "sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw=="], + + "@vitest/mocker": ["@vitest/mocker@2.1.9", "", { "dependencies": { "@vitest/spy": "2.1.9", "estree-walker": "3.0.3", "magic-string": "0.30.21" }, "optionalDependencies": { "vite": "5.4.21" } }, "sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg=="], + + "@vitest/pretty-format": ["@vitest/pretty-format@2.1.9", "", { "dependencies": { "tinyrainbow": "1.2.0" } }, "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ=="], + + "@vitest/runner": ["@vitest/runner@2.1.9", "", { "dependencies": { "@vitest/utils": "2.1.9", "pathe": "1.1.2" } }, "sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g=="], + + "@vitest/snapshot": ["@vitest/snapshot@2.1.9", "", { "dependencies": { "@vitest/pretty-format": "2.1.9", "magic-string": "0.30.21", "pathe": "1.1.2" } }, "sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ=="], + + "@vitest/spy": ["@vitest/spy@2.1.9", "", { "dependencies": { "tinyspy": "3.0.2" } }, "sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ=="], + + "@vitest/utils": ["@vitest/utils@2.1.9", "", { "dependencies": { "@vitest/pretty-format": "2.1.9", "loupe": "3.2.1", "tinyrainbow": "1.2.0" } }, "sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ=="], + + "assertion-error": ["assertion-error@2.0.1", "", {}, "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA=="], + + "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="], + + "chai": ["chai@5.3.3", "", { "dependencies": { "assertion-error": "2.0.1", "check-error": "2.1.3", "deep-eql": "5.0.2", "loupe": "3.2.1", "pathval": "2.0.1" } }, "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw=="], + + "check-error": ["check-error@2.1.3", "", {}, "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA=="], + + "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], + + "deep-eql": ["deep-eql@5.0.2", "", {}, "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q=="], + + "es-module-lexer": ["es-module-lexer@1.7.0", "", {}, "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA=="], + + "esbuild": ["esbuild@0.21.5", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.21.5", "@esbuild/android-arm": "0.21.5", "@esbuild/android-arm64": "0.21.5", "@esbuild/android-x64": "0.21.5", "@esbuild/darwin-arm64": "0.21.5", "@esbuild/darwin-x64": "0.21.5", "@esbuild/freebsd-arm64": "0.21.5", "@esbuild/freebsd-x64": "0.21.5", "@esbuild/linux-arm": "0.21.5", "@esbuild/linux-arm64": "0.21.5", "@esbuild/linux-ia32": "0.21.5", "@esbuild/linux-loong64": "0.21.5", "@esbuild/linux-mips64el": "0.21.5", "@esbuild/linux-ppc64": "0.21.5", "@esbuild/linux-riscv64": "0.21.5", "@esbuild/linux-s390x": "0.21.5", "@esbuild/linux-x64": "0.21.5", "@esbuild/netbsd-x64": "0.21.5", "@esbuild/openbsd-x64": "0.21.5", "@esbuild/sunos-x64": "0.21.5", "@esbuild/win32-arm64": "0.21.5", "@esbuild/win32-ia32": "0.21.5", "@esbuild/win32-x64": "0.21.5" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw=="], + + "estree-walker": ["estree-walker@3.0.3", "", { "dependencies": { "@types/estree": "1.0.8" } }, "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g=="], + + "expect-type": ["expect-type@1.3.0", "", {}, "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA=="], + + "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], + + "happy-dom": ["happy-dom@16.8.1", "", { "dependencies": { "webidl-conversions": "7.0.0", "whatwg-mimetype": "3.0.0" } }, "sha512-n0QrmT9lD81rbpKsyhnlz3DgnMZlaOkJPpgi746doA+HvaMC79bdWkwjrNnGJRvDrWTI8iOcJiVTJ5CdT/AZRw=="], + + "highlight.js": ["highlight.js@11.11.1", "", {}, "sha512-Xwwo44whKBVCYoliBQwaPvtd/2tYFkRQtXDWj1nackaV2JPXx3L0+Jvd8/qCJ2p+ML0/XVkJ2q+Mr+UVdpJK5w=="], + + "loupe": ["loupe@3.2.1", "", {}, "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ=="], + + "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="], + + "marked": ["marked@17.0.4", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-NOmVMM+KAokHMvjWmC5N/ZOvgmSWuqJB8FoYI019j4ogb/PeRMKoKIjReZ2w3376kkA8dSJIP8uD993Kxc0iRQ=="], + + "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="], + + "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="], + + "pathe": ["pathe@1.1.2", "", {}, "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ=="], + + "pathval": ["pathval@2.0.1", "", {}, "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ=="], + + "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="], + + "postcss": ["postcss@8.5.8", "", { "dependencies": { "nanoid": "3.3.11", "picocolors": "1.1.1", "source-map-js": "1.2.1" } }, "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg=="], + + "rollup": ["rollup@4.59.0", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.59.0", "@rollup/rollup-android-arm64": "4.59.0", "@rollup/rollup-darwin-arm64": "4.59.0", "@rollup/rollup-darwin-x64": "4.59.0", "@rollup/rollup-freebsd-arm64": "4.59.0", "@rollup/rollup-freebsd-x64": "4.59.0", "@rollup/rollup-linux-arm-gnueabihf": "4.59.0", "@rollup/rollup-linux-arm-musleabihf": "4.59.0", "@rollup/rollup-linux-arm64-gnu": "4.59.0", "@rollup/rollup-linux-arm64-musl": "4.59.0", "@rollup/rollup-linux-loong64-gnu": "4.59.0", "@rollup/rollup-linux-loong64-musl": "4.59.0", "@rollup/rollup-linux-ppc64-gnu": "4.59.0", "@rollup/rollup-linux-ppc64-musl": "4.59.0", "@rollup/rollup-linux-riscv64-gnu": "4.59.0", "@rollup/rollup-linux-riscv64-musl": "4.59.0", "@rollup/rollup-linux-s390x-gnu": "4.59.0", "@rollup/rollup-linux-x64-gnu": "4.59.0", "@rollup/rollup-linux-x64-musl": "4.59.0", "@rollup/rollup-openbsd-x64": "4.59.0", "@rollup/rollup-openharmony-arm64": "4.59.0", "@rollup/rollup-win32-arm64-msvc": "4.59.0", "@rollup/rollup-win32-ia32-msvc": "4.59.0", "@rollup/rollup-win32-x64-gnu": "4.59.0", "@rollup/rollup-win32-x64-msvc": "4.59.0", "fsevents": "2.3.3" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg=="], + + "siginfo": ["siginfo@2.0.0", "", {}, "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g=="], + + "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="], + + "stackback": ["stackback@0.0.2", "", {}, "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw=="], + + "std-env": ["std-env@3.10.0", "", {}, "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg=="], + + "tinybench": ["tinybench@2.9.0", "", {}, "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg=="], + + "tinyexec": ["tinyexec@0.3.2", "", {}, "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA=="], + + "tinypool": ["tinypool@1.1.1", "", {}, "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg=="], + + "tinyrainbow": ["tinyrainbow@1.2.0", "", {}, "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ=="], + + "tinyspy": ["tinyspy@3.0.2", "", {}, "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q=="], + + "vite": ["vite@5.4.21", "", { "dependencies": { "esbuild": "0.21.5", "postcss": "8.5.8", "rollup": "4.59.0" }, "optionalDependencies": { "fsevents": "2.3.3" }, "bin": { "vite": "bin/vite.js" } }, "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw=="], + + "vite-node": ["vite-node@2.1.9", "", { "dependencies": { "cac": "6.7.14", "debug": "4.4.3", "es-module-lexer": "1.7.0", "pathe": "1.1.2", "vite": "5.4.21" }, "bin": { "vite-node": "vite-node.mjs" } }, "sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA=="], + + "vitest": ["vitest@2.1.9", "", { "dependencies": { "@vitest/expect": "2.1.9", "@vitest/mocker": "2.1.9", "@vitest/pretty-format": "2.1.9", "@vitest/runner": "2.1.9", "@vitest/snapshot": "2.1.9", "@vitest/spy": "2.1.9", "@vitest/utils": "2.1.9", "chai": "5.3.3", "debug": "4.4.3", "expect-type": "1.3.0", "magic-string": "0.30.21", "pathe": "1.1.2", "std-env": "3.10.0", "tinybench": "2.9.0", "tinyexec": "0.3.2", "tinypool": "1.1.1", "tinyrainbow": "1.2.0", "vite": "5.4.21", "vite-node": "2.1.9", "why-is-node-running": "2.3.0" }, "optionalDependencies": { "happy-dom": "16.8.1" }, "bin": { "vitest": "vitest.mjs" } }, "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q=="], + + "webidl-conversions": ["webidl-conversions@7.0.0", "", {}, "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g=="], + + "whatwg-mimetype": ["whatwg-mimetype@3.0.0", "", {}, "sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q=="], + + "why-is-node-running": ["why-is-node-running@2.3.0", "", { "dependencies": { "siginfo": "2.0.0", "stackback": "0.0.2" }, "bin": { "why-is-node-running": "cli.js" } }, "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w=="], + } +} diff --git a/pkg/miniapp/frontend/package.json b/pkg/miniapp/frontend/package.json index b36db1154..4a6497882 100644 --- a/pkg/miniapp/frontend/package.json +++ b/pkg/miniapp/frontend/package.json @@ -9,6 +9,9 @@ "devDependencies": { "happy-dom": "^16.8.1", "vitest": "^2.1.9" + }, + "dependencies": { + "highlight.js": "^11.11.1", + "marked": "^17.0.4" } } - diff --git a/pkg/miniapp/frontend/src/app.js b/pkg/miniapp/frontend/src/app.js index 009d500bb..03fe1066a 100644 --- a/pkg/miniapp/frontend/src/app.js +++ b/pkg/miniapp/frontend/src/app.js @@ -1,6 +1,50 @@ import './styles.css'; +import 'highlight.js/styles/github-dark.min.css'; +import { marked } from 'marked'; +import hljs from 'highlight.js/lib/core'; +import javascript from 'highlight.js/lib/languages/javascript'; +import python from 'highlight.js/lib/languages/python'; +import go from 'highlight.js/lib/languages/go'; +import bash from 'highlight.js/lib/languages/bash'; +import json from 'highlight.js/lib/languages/json'; +import yaml from 'highlight.js/lib/languages/yaml'; +import typescript from 'highlight.js/lib/languages/typescript'; +import sql from 'highlight.js/lib/languages/sql'; +import xml from 'highlight.js/lib/languages/xml'; +import css from 'highlight.js/lib/languages/css'; +import markdown from 'highlight.js/lib/languages/markdown'; import { renderLogs as renderLogsView } from './logs_view.js'; +hljs.registerLanguage('javascript', javascript); +hljs.registerLanguage('js', javascript); +hljs.registerLanguage('python', python); +hljs.registerLanguage('py', python); +hljs.registerLanguage('go', go); +hljs.registerLanguage('bash', bash); +hljs.registerLanguage('sh', bash); +hljs.registerLanguage('json', json); +hljs.registerLanguage('yaml', yaml); +hljs.registerLanguage('yml', yaml); +hljs.registerLanguage('typescript', typescript); +hljs.registerLanguage('ts', typescript); +hljs.registerLanguage('sql', sql); +hljs.registerLanguage('xml', xml); +hljs.registerLanguage('html', xml); +hljs.registerLanguage('css', css); +hljs.registerLanguage('markdown', markdown); +hljs.registerLanguage('md', markdown); + +marked.setOptions({ + highlight: function(code, lang) { + if (lang && hljs.getLanguage(lang)) { + return hljs.highlight(code, { language: lang }).value; + } + return hljs.highlightAuto(code).value; + }, + breaks: true, + gfm: true, +}); + const tg = window.Telegram.WebApp; tg.ready(); @@ -246,37 +290,7 @@ function setupSlideApprove() { } function renderSimpleMarkdown(text) { - var lines = text.split('\n'); - var out = []; - for (var i = 0; i < lines.length; i++) { - var line = lines[i]; - // Headings - if (/^### /.test(line)) { - out.push('
' + escapeHtml(line.slice(4)) + '
'); - } else if (/^## /.test(line)) { - out.push('
' + escapeHtml(line.slice(3)) + '
'); - } else if (/^# /.test(line)) { - out.push('
' + escapeHtml(line.slice(2)) + '
'); - // Checkboxes - } else if (/^- \[x\] /.test(line)) { - out.push('
' + escapeHtml(line.slice(6)) + '
'); - } else if (/^- \[ \] /.test(line)) { - out.push('
' + escapeHtml(line.slice(6)) + '
'); - // Blockquote - } else if (/^> /.test(line)) { - out.push('
' + escapeHtml(line.slice(2)) + '
'); - // Bullet list - } else if (/^- /.test(line)) { - out.push('
' + escapeHtml(line.slice(2)) + '
'); - // Empty line - } else if (line.trim() === '') { - out.push('
'); - // Plain text - } else { - out.push('
' + escapeHtml(line) + '
'); - } - } - return out.join(''); + return marked.parse(text); } async function loadTab(loadingId, contentId, label, fetchFn, renderFn) { @@ -1468,8 +1482,8 @@ async function toggleResearchDoc(card, taskId, docId) { ); var data = await resp.json(); body.dataset.loaded = '1'; - body.innerHTML = '
' +
-      esc(data.content) + '
'; + body.innerHTML = '
' + + marked.parse(data.content) + '
'; } catch (e) { body.innerHTML = '
Failed to load document.
'; } diff --git a/pkg/miniapp/frontend/src/styles.css b/pkg/miniapp/frontend/src/styles.css index 7847478d4..d4d0fa026 100644 --- a/pkg/miniapp/frontend/src/styles.css +++ b/pkg/miniapp/frontend/src/styles.css @@ -472,6 +472,70 @@ color: var(--hint); } + /* Rendered markdown (marked + highlight.js) */ + .md-rendered { + font-size: 14px; + line-height: 1.6; + word-break: break-word; + } + .md-rendered h1 { font-size: 18px; font-weight: 700; margin: 16px 0 8px; } + .md-rendered h1:first-child { margin-top: 0; } + .md-rendered h2 { font-size: 16px; font-weight: 700; margin: 14px 0 6px; color: var(--link); } + .md-rendered h3 { font-size: 14px; font-weight: 600; margin: 12px 0 4px; } + .md-rendered p { margin: 6px 0; } + .md-rendered ul, .md-rendered ol { padding-left: 20px; margin: 6px 0; } + .md-rendered li { margin: 2px 0; } + .md-rendered blockquote { + border-left: 3px solid var(--hint); + padding-left: 10px; + color: var(--hint); + margin: 6px 0; + } + .md-rendered a { color: var(--link); } + .md-rendered strong { font-weight: 700; } + .md-rendered hr { + border: none; + border-top: 1px solid var(--glass-divider); + margin: 10px 0; + } + .md-rendered code { + font-family: 'SF Mono', 'Menlo', 'Consolas', monospace; + font-size: 0.9em; + background: var(--tab-track-bg); + border-radius: 4px; + padding: 1px 5px; + } + .md-rendered pre { + border-radius: 8px; + padding: 10px 12px; + margin: 8px 0; + overflow-x: auto; + font-size: 12px; + line-height: 1.5; + } + .md-rendered pre code { + background: none; + padding: 0; + border-radius: 0; + font-size: inherit; + } + .md-rendered table { + border-collapse: collapse; + margin: 8px 0; + font-size: 13px; + width: 100%; + } + .md-rendered th, .md-rendered td { + border: 1px solid var(--glass-border); + padding: 6px 10px; + text-align: left; + } + .md-rendered th { + background: var(--tab-track-bg); + font-weight: 600; + } + .md-rendered img { max-width: 100%; border-radius: 8px; } + /* Slide to Approve */ .slide-approve-wrap { margin-top: 16px; diff --git a/pkg/miniapp/static/dist/app.css b/pkg/miniapp/static/dist/app.css index 27b0f8337..f4b1900b1 100644 --- a/pkg/miniapp/static/dist/app.css +++ b/pkg/miniapp/static/dist/app.css @@ -519,6 +519,116 @@ body { color: var(--hint); } +.md-rendered { + word-break: break-word; + font-size: 14px; + line-height: 1.6; +} + +.md-rendered h1 { + margin: 16px 0 8px; + font-size: 18px; + font-weight: 700; +} + +.md-rendered h1:first-child { + margin-top: 0; +} + +.md-rendered h2 { + color: var(--link); + margin: 14px 0 6px; + font-size: 16px; + font-weight: 700; +} + +.md-rendered h3 { + margin: 12px 0 4px; + font-size: 14px; + font-weight: 600; +} + +.md-rendered p { + margin: 6px 0; +} + +.md-rendered ul, .md-rendered ol { + margin: 6px 0; + padding-left: 20px; +} + +.md-rendered li { + margin: 2px 0; +} + +.md-rendered blockquote { + border-left: 3px solid var(--hint); + color: var(--hint); + margin: 6px 0; + padding-left: 10px; +} + +.md-rendered a { + color: var(--link); +} + +.md-rendered strong { + font-weight: 700; +} + +.md-rendered hr { + border: none; + border-top: 1px solid var(--glass-divider); + margin: 10px 0; +} + +.md-rendered code { + background: var(--tab-track-bg); + border-radius: 4px; + padding: 1px 5px; + font-family: SF Mono, Menlo, Consolas, monospace; + font-size: .9em; +} + +.md-rendered pre { + overflow-x: auto; + border-radius: 8px; + margin: 8px 0; + padding: 10px 12px; + font-size: 12px; + line-height: 1.5; +} + +.md-rendered pre code { + font-size: inherit; + background: none; + border-radius: 0; + padding: 0; +} + +.md-rendered table { + border-collapse: collapse; + width: 100%; + margin: 8px 0; + font-size: 13px; +} + +.md-rendered th, .md-rendered td { + border: 1px solid var(--glass-border); + text-align: left; + padding: 6px 10px; +} + +.md-rendered th { + background: var(--tab-track-bg); + font-weight: 600; +} + +.md-rendered img { + border-radius: 8px; + max-width: 100%; +} + .slide-approve-wrap { margin-top: 16px; } @@ -1228,3 +1338,80 @@ body { .session-tree-icon.completed { color: var(--hint); } + +/* node_modules/highlight.js/styles/github-dark.min.css */ +pre code.hljs { + display: block; + overflow-x: auto; + padding: 1em; +} + +code.hljs { + padding: 3px 5px; +} + +.hljs { + color: #c9d1d9; + background: #0d1117; +} + +.hljs-doctag, .hljs-keyword, .hljs-meta .hljs-keyword, .hljs-template-tag, .hljs-template-variable, .hljs-type, .hljs-variable.language_ { + color: #ff7b72; +} + +.hljs-title, .hljs-title.class_, .hljs-title.class_.inherited__, .hljs-title.function_ { + color: #d2a8ff; +} + +.hljs-attr, .hljs-attribute, .hljs-literal, .hljs-meta, .hljs-number, .hljs-operator, .hljs-selector-attr, .hljs-selector-class, .hljs-selector-id, .hljs-variable { + color: #79c0ff; +} + +.hljs-meta .hljs-string, .hljs-regexp, .hljs-string { + color: #a5d6ff; +} + +.hljs-built_in, .hljs-symbol { + color: #ffa657; +} + +.hljs-code, .hljs-comment, .hljs-formula { + color: #8b949e; +} + +.hljs-name, .hljs-quote, .hljs-selector-pseudo, .hljs-selector-tag { + color: #7ee787; +} + +.hljs-subst { + color: #c9d1d9; +} + +.hljs-section { + color: #1f6feb; + font-weight: 700; +} + +.hljs-bullet { + color: #f2cc60; +} + +.hljs-emphasis { + color: #c9d1d9; + font-style: italic; +} + +.hljs-strong { + color: #c9d1d9; + font-weight: 700; +} + +.hljs-addition { + color: #aff5b4; + background-color: #033a16; +} + +.hljs-deletion { + color: #ffdcd7; + background-color: #67060c; +} diff --git a/pkg/miniapp/static/dist/app.js b/pkg/miniapp/static/dist/app.js index de2e00f8e..9d7855aec 100644 --- a/pkg/miniapp/static/dist/app.js +++ b/pkg/miniapp/static/dist/app.js @@ -1,4 +1,7158 @@ (() => { + var __create = Object.create; + var __getProtoOf = Object.getPrototypeOf; + var __defProp = Object.defineProperty; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __hasOwnProp = Object.prototype.hasOwnProperty; + function __accessProp(key) { + return this[key]; + } + var __toESMCache_node; + var __toESMCache_esm; + var __toESM = (mod, isNodeMode, target) => { + var canCache = mod != null && typeof mod === "object"; + if (canCache) { + var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap; + var cached = cache.get(mod); + if (cached) + return cached; + } + target = mod != null ? __create(__getProtoOf(mod)) : {}; + const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target; + for (let key of __getOwnPropNames(mod)) + if (!__hasOwnProp.call(to, key)) + __defProp(to, key, { + get: __accessProp.bind(mod, key), + enumerable: true + }); + if (canCache) + cache.set(mod, to); + return to; + }; + var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports); + + // node_modules/highlight.js/lib/core.js + var require_core = __commonJS((exports, module) => { + function deepFreeze(obj) { + if (obj instanceof Map) { + obj.clear = obj.delete = obj.set = function() { + throw new Error("map is read-only"); + }; + } else if (obj instanceof Set) { + obj.add = obj.clear = obj.delete = function() { + throw new Error("set is read-only"); + }; + } + Object.freeze(obj); + Object.getOwnPropertyNames(obj).forEach((name) => { + const prop = obj[name]; + const type = typeof prop; + if ((type === "object" || type === "function") && !Object.isFrozen(prop)) { + deepFreeze(prop); + } + }); + return obj; + } + + class Response { + constructor(mode) { + if (mode.data === undefined) + mode.data = {}; + this.data = mode.data; + this.isMatchIgnored = false; + } + ignoreMatch() { + this.isMatchIgnored = true; + } + } + function escapeHTML(value) { + return value.replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/'/g, "'"); + } + function inherit$1(original, ...objects) { + const result = Object.create(null); + for (const key in original) { + result[key] = original[key]; + } + objects.forEach(function(obj) { + for (const key in obj) { + result[key] = obj[key]; + } + }); + return result; + } + var SPAN_CLOSE = ""; + var emitsWrappingTags = (node) => { + return !!node.scope; + }; + var scopeToCSSClass = (name, { prefix }) => { + if (name.startsWith("language:")) { + return name.replace("language:", "language-"); + } + if (name.includes(".")) { + const pieces = name.split("."); + return [ + `${prefix}${pieces.shift()}`, + ...pieces.map((x2, i) => `${x2}${"_".repeat(i + 1)}`) + ].join(" "); + } + return `${prefix}${name}`; + }; + + class HTMLRenderer { + constructor(parseTree, options) { + this.buffer = ""; + this.classPrefix = options.classPrefix; + parseTree.walk(this); + } + addText(text) { + this.buffer += escapeHTML(text); + } + openNode(node) { + if (!emitsWrappingTags(node)) + return; + const className = scopeToCSSClass(node.scope, { prefix: this.classPrefix }); + this.span(className); + } + closeNode(node) { + if (!emitsWrappingTags(node)) + return; + this.buffer += SPAN_CLOSE; + } + value() { + return this.buffer; + } + span(className) { + this.buffer += ``; + } + } + var newNode = (opts = {}) => { + const result = { children: [] }; + Object.assign(result, opts); + return result; + }; + + class TokenTree { + constructor() { + this.rootNode = newNode(); + this.stack = [this.rootNode]; + } + get top() { + return this.stack[this.stack.length - 1]; + } + get root() { + return this.rootNode; + } + add(node) { + this.top.children.push(node); + } + openNode(scope) { + const node = newNode({ scope }); + this.add(node); + this.stack.push(node); + } + closeNode() { + if (this.stack.length > 1) { + return this.stack.pop(); + } + return; + } + closeAllNodes() { + while (this.closeNode()) + ; + } + toJSON() { + return JSON.stringify(this.rootNode, null, 4); + } + walk(builder) { + return this.constructor._walk(builder, this.rootNode); + } + static _walk(builder, node) { + if (typeof node === "string") { + builder.addText(node); + } else if (node.children) { + builder.openNode(node); + node.children.forEach((child) => this._walk(builder, child)); + builder.closeNode(node); + } + return builder; + } + static _collapse(node) { + if (typeof node === "string") + return; + if (!node.children) + return; + if (node.children.every((el) => typeof el === "string")) { + node.children = [node.children.join("")]; + } else { + node.children.forEach((child) => { + TokenTree._collapse(child); + }); + } + } + } + + class TokenTreeEmitter extends TokenTree { + constructor(options) { + super(); + this.options = options; + } + addText(text) { + if (text === "") { + return; + } + this.add(text); + } + startScope(scope) { + this.openNode(scope); + } + endScope() { + this.closeNode(); + } + __addSublanguage(emitter, name) { + const node = emitter.root; + if (name) + node.scope = `language:${name}`; + this.add(node); + } + toHTML() { + const renderer = new HTMLRenderer(this, this.options); + return renderer.value(); + } + finalize() { + this.closeAllNodes(); + return true; + } + } + function source(re2) { + if (!re2) + return null; + if (typeof re2 === "string") + return re2; + return re2.source; + } + function lookahead(re2) { + return concat("(?=", re2, ")"); + } + function anyNumberOfTimes(re2) { + return concat("(?:", re2, ")*"); + } + function optional(re2) { + return concat("(?:", re2, ")?"); + } + function concat(...args) { + const joined = args.map((x2) => source(x2)).join(""); + return joined; + } + function stripOptionsFromArgs(args) { + const opts = args[args.length - 1]; + if (typeof opts === "object" && opts.constructor === Object) { + args.splice(args.length - 1, 1); + return opts; + } else { + return {}; + } + } + function either(...args) { + const opts = stripOptionsFromArgs(args); + const joined = "(" + (opts.capture ? "" : "?:") + args.map((x2) => source(x2)).join("|") + ")"; + return joined; + } + function countMatchGroups(re2) { + return new RegExp(re2.toString() + "|").exec("").length - 1; + } + function startsWith(re2, lexeme) { + const match = re2 && re2.exec(lexeme); + return match && match.index === 0; + } + var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./; + function _rewriteBackreferences(regexps, { joinWith }) { + let numCaptures = 0; + return regexps.map((regex) => { + numCaptures += 1; + const offset = numCaptures; + let re2 = source(regex); + let out = ""; + while (re2.length > 0) { + const match = BACKREF_RE.exec(re2); + if (!match) { + out += re2; + break; + } + out += re2.substring(0, match.index); + re2 = re2.substring(match.index + match[0].length); + if (match[0][0] === "\\" && match[1]) { + out += "\\" + String(Number(match[1]) + offset); + } else { + out += match[0]; + if (match[0] === "(") { + numCaptures++; + } + } + } + return out; + }).map((re2) => `(${re2})`).join(joinWith); + } + var MATCH_NOTHING_RE = /\b\B/; + var IDENT_RE = "[a-zA-Z]\\w*"; + var UNDERSCORE_IDENT_RE = "[a-zA-Z_]\\w*"; + var NUMBER_RE = "\\b\\d+(\\.\\d+)?"; + var C_NUMBER_RE = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)"; + var BINARY_NUMBER_RE = "\\b(0b[01]+)"; + var RE_STARTERS_RE = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~"; + var SHEBANG = (opts = {}) => { + const beginShebang = /^#![ ]*\//; + if (opts.binary) { + opts.begin = concat(beginShebang, /.*\b/, opts.binary, /\b.*/); + } + return inherit$1({ + scope: "meta", + begin: beginShebang, + end: /$/, + relevance: 0, + "on:begin": (m2, resp) => { + if (m2.index !== 0) + resp.ignoreMatch(); + } + }, opts); + }; + var BACKSLASH_ESCAPE = { + begin: "\\\\[\\s\\S]", + relevance: 0 + }; + var APOS_STRING_MODE = { + scope: "string", + begin: "'", + end: "'", + illegal: "\\n", + contains: [BACKSLASH_ESCAPE] + }; + var QUOTE_STRING_MODE = { + scope: "string", + begin: '"', + end: '"', + illegal: "\\n", + contains: [BACKSLASH_ESCAPE] + }; + var PHRASAL_WORDS_MODE = { + begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/ + }; + var COMMENT = function(begin, end, modeOptions = {}) { + const mode = inherit$1({ + scope: "comment", + begin, + end, + contains: [] + }, modeOptions); + mode.contains.push({ + scope: "doctag", + begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)", + end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/, + excludeBegin: true, + relevance: 0 + }); + const ENGLISH_WORD = either("I", "a", "is", "so", "us", "to", "at", "if", "in", "it", "on", /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, /[A-Za-z]+[-][a-z]+/, /[A-Za-z][a-z]{2,}/); + mode.contains.push({ + begin: concat(/[ ]+/, "(", ENGLISH_WORD, /[.]?[:]?([.][ ]|[ ])/, "){3}") + }); + return mode; + }; + var C_LINE_COMMENT_MODE = COMMENT("//", "$"); + var C_BLOCK_COMMENT_MODE = COMMENT("/\\*", "\\*/"); + var HASH_COMMENT_MODE = COMMENT("#", "$"); + var NUMBER_MODE = { + scope: "number", + begin: NUMBER_RE, + relevance: 0 + }; + var C_NUMBER_MODE = { + scope: "number", + begin: C_NUMBER_RE, + relevance: 0 + }; + var BINARY_NUMBER_MODE = { + scope: "number", + begin: BINARY_NUMBER_RE, + relevance: 0 + }; + var REGEXP_MODE = { + scope: "regexp", + begin: /\/(?=[^/\n]*\/)/, + end: /\/[gimuy]*/, + contains: [ + BACKSLASH_ESCAPE, + { + begin: /\[/, + end: /\]/, + relevance: 0, + contains: [BACKSLASH_ESCAPE] + } + ] + }; + var TITLE_MODE = { + scope: "title", + begin: IDENT_RE, + relevance: 0 + }; + var UNDERSCORE_TITLE_MODE = { + scope: "title", + begin: UNDERSCORE_IDENT_RE, + relevance: 0 + }; + var METHOD_GUARD = { + begin: "\\.\\s*" + UNDERSCORE_IDENT_RE, + relevance: 0 + }; + var END_SAME_AS_BEGIN = function(mode) { + return Object.assign(mode, { + "on:begin": (m2, resp) => { + resp.data._beginMatch = m2[1]; + }, + "on:end": (m2, resp) => { + if (resp.data._beginMatch !== m2[1]) + resp.ignoreMatch(); + } + }); + }; + var MODES = /* @__PURE__ */ Object.freeze({ + __proto__: null, + APOS_STRING_MODE, + BACKSLASH_ESCAPE, + BINARY_NUMBER_MODE, + BINARY_NUMBER_RE, + COMMENT, + C_BLOCK_COMMENT_MODE, + C_LINE_COMMENT_MODE, + C_NUMBER_MODE, + C_NUMBER_RE, + END_SAME_AS_BEGIN, + HASH_COMMENT_MODE, + IDENT_RE, + MATCH_NOTHING_RE, + METHOD_GUARD, + NUMBER_MODE, + NUMBER_RE, + PHRASAL_WORDS_MODE, + QUOTE_STRING_MODE, + REGEXP_MODE, + RE_STARTERS_RE, + SHEBANG, + TITLE_MODE, + UNDERSCORE_IDENT_RE, + UNDERSCORE_TITLE_MODE + }); + function skipIfHasPrecedingDot(match, response) { + const before = match.input[match.index - 1]; + if (before === ".") { + response.ignoreMatch(); + } + } + function scopeClassName(mode, _parent) { + if (mode.className !== undefined) { + mode.scope = mode.className; + delete mode.className; + } + } + function beginKeywords(mode, parent) { + if (!parent) + return; + if (!mode.beginKeywords) + return; + mode.begin = "\\b(" + mode.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)"; + mode.__beforeBegin = skipIfHasPrecedingDot; + mode.keywords = mode.keywords || mode.beginKeywords; + delete mode.beginKeywords; + if (mode.relevance === undefined) + mode.relevance = 0; + } + function compileIllegal(mode, _parent) { + if (!Array.isArray(mode.illegal)) + return; + mode.illegal = either(...mode.illegal); + } + function compileMatch(mode, _parent) { + if (!mode.match) + return; + if (mode.begin || mode.end) + throw new Error("begin & end are not supported with match"); + mode.begin = mode.match; + delete mode.match; + } + function compileRelevance(mode, _parent) { + if (mode.relevance === undefined) + mode.relevance = 1; + } + var beforeMatchExt = (mode, parent) => { + if (!mode.beforeMatch) + return; + if (mode.starts) + throw new Error("beforeMatch cannot be used with starts"); + const originalMode = Object.assign({}, mode); + Object.keys(mode).forEach((key) => { + delete mode[key]; + }); + mode.keywords = originalMode.keywords; + mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin)); + mode.starts = { + relevance: 0, + contains: [ + Object.assign(originalMode, { endsParent: true }) + ] + }; + mode.relevance = 0; + delete originalMode.beforeMatch; + }; + var COMMON_KEYWORDS = [ + "of", + "and", + "for", + "in", + "not", + "or", + "if", + "then", + "parent", + "list", + "value" + ]; + var DEFAULT_KEYWORD_SCOPE = "keyword"; + function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) { + const compiledKeywords = Object.create(null); + if (typeof rawKeywords === "string") { + compileList(scopeName, rawKeywords.split(" ")); + } else if (Array.isArray(rawKeywords)) { + compileList(scopeName, rawKeywords); + } else { + Object.keys(rawKeywords).forEach(function(scopeName2) { + Object.assign(compiledKeywords, compileKeywords(rawKeywords[scopeName2], caseInsensitive, scopeName2)); + }); + } + return compiledKeywords; + function compileList(scopeName2, keywordList) { + if (caseInsensitive) { + keywordList = keywordList.map((x2) => x2.toLowerCase()); + } + keywordList.forEach(function(keyword) { + const pair = keyword.split("|"); + compiledKeywords[pair[0]] = [scopeName2, scoreForKeyword(pair[0], pair[1])]; + }); + } + } + function scoreForKeyword(keyword, providedScore) { + if (providedScore) { + return Number(providedScore); + } + return commonKeyword(keyword) ? 0 : 1; + } + function commonKeyword(keyword) { + return COMMON_KEYWORDS.includes(keyword.toLowerCase()); + } + var seenDeprecations = {}; + var error = (message) => { + console.error(message); + }; + var warn = (message, ...args) => { + console.log(`WARN: ${message}`, ...args); + }; + var deprecated = (version2, message) => { + if (seenDeprecations[`${version2}/${message}`]) + return; + console.log(`Deprecated as of ${version2}. ${message}`); + seenDeprecations[`${version2}/${message}`] = true; + }; + var MultiClassError = new Error; + function remapScopeNames(mode, regexes, { key }) { + let offset = 0; + const scopeNames = mode[key]; + const emit = {}; + const positions = {}; + for (let i = 1;i <= regexes.length; i++) { + positions[i + offset] = scopeNames[i]; + emit[i + offset] = true; + offset += countMatchGroups(regexes[i - 1]); + } + mode[key] = positions; + mode[key]._emit = emit; + mode[key]._multi = true; + } + function beginMultiClass(mode) { + if (!Array.isArray(mode.begin)) + return; + if (mode.skip || mode.excludeBegin || mode.returnBegin) { + error("skip, excludeBegin, returnBegin not compatible with beginScope: {}"); + throw MultiClassError; + } + if (typeof mode.beginScope !== "object" || mode.beginScope === null) { + error("beginScope must be object"); + throw MultiClassError; + } + remapScopeNames(mode, mode.begin, { key: "beginScope" }); + mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" }); + } + function endMultiClass(mode) { + if (!Array.isArray(mode.end)) + return; + if (mode.skip || mode.excludeEnd || mode.returnEnd) { + error("skip, excludeEnd, returnEnd not compatible with endScope: {}"); + throw MultiClassError; + } + if (typeof mode.endScope !== "object" || mode.endScope === null) { + error("endScope must be object"); + throw MultiClassError; + } + remapScopeNames(mode, mode.end, { key: "endScope" }); + mode.end = _rewriteBackreferences(mode.end, { joinWith: "" }); + } + function scopeSugar(mode) { + if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) { + mode.beginScope = mode.scope; + delete mode.scope; + } + } + function MultiClass(mode) { + scopeSugar(mode); + if (typeof mode.beginScope === "string") { + mode.beginScope = { _wrap: mode.beginScope }; + } + if (typeof mode.endScope === "string") { + mode.endScope = { _wrap: mode.endScope }; + } + beginMultiClass(mode); + endMultiClass(mode); + } + function compileLanguage(language) { + function langRe(value, global) { + return new RegExp(source(value), "m" + (language.case_insensitive ? "i" : "") + (language.unicodeRegex ? "u" : "") + (global ? "g" : "")); + } + + class MultiRegex { + constructor() { + this.matchIndexes = {}; + this.regexes = []; + this.matchAt = 1; + this.position = 0; + } + addRule(re2, opts) { + opts.position = this.position++; + this.matchIndexes[this.matchAt] = opts; + this.regexes.push([opts, re2]); + this.matchAt += countMatchGroups(re2) + 1; + } + compile() { + if (this.regexes.length === 0) { + this.exec = () => null; + } + const terminators = this.regexes.map((el) => el[1]); + this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: "|" }), true); + this.lastIndex = 0; + } + exec(s) { + this.matcherRe.lastIndex = this.lastIndex; + const match = this.matcherRe.exec(s); + if (!match) { + return null; + } + const i = match.findIndex((el, i2) => i2 > 0 && el !== undefined); + const matchData = this.matchIndexes[i]; + match.splice(0, i); + return Object.assign(match, matchData); + } + } + + class ResumableMultiRegex { + constructor() { + this.rules = []; + this.multiRegexes = []; + this.count = 0; + this.lastIndex = 0; + this.regexIndex = 0; + } + getMatcher(index) { + if (this.multiRegexes[index]) + return this.multiRegexes[index]; + const matcher = new MultiRegex; + this.rules.slice(index).forEach(([re2, opts]) => matcher.addRule(re2, opts)); + matcher.compile(); + this.multiRegexes[index] = matcher; + return matcher; + } + resumingScanAtSamePosition() { + return this.regexIndex !== 0; + } + considerAll() { + this.regexIndex = 0; + } + addRule(re2, opts) { + this.rules.push([re2, opts]); + if (opts.type === "begin") + this.count++; + } + exec(s) { + const m2 = this.getMatcher(this.regexIndex); + m2.lastIndex = this.lastIndex; + let result = m2.exec(s); + if (this.resumingScanAtSamePosition()) { + if (result && result.index === this.lastIndex) + ; + else { + const m22 = this.getMatcher(0); + m22.lastIndex = this.lastIndex + 1; + result = m22.exec(s); + } + } + if (result) { + this.regexIndex += result.position + 1; + if (this.regexIndex === this.count) { + this.considerAll(); + } + } + return result; + } + } + function buildModeRegex(mode) { + const mm = new ResumableMultiRegex; + mode.contains.forEach((term) => mm.addRule(term.begin, { rule: term, type: "begin" })); + if (mode.terminatorEnd) { + mm.addRule(mode.terminatorEnd, { type: "end" }); + } + if (mode.illegal) { + mm.addRule(mode.illegal, { type: "illegal" }); + } + return mm; + } + function compileMode(mode, parent) { + const cmode = mode; + if (mode.isCompiled) + return cmode; + [ + scopeClassName, + compileMatch, + MultiClass, + beforeMatchExt + ].forEach((ext) => ext(mode, parent)); + language.compilerExtensions.forEach((ext) => ext(mode, parent)); + mode.__beforeBegin = null; + [ + beginKeywords, + compileIllegal, + compileRelevance + ].forEach((ext) => ext(mode, parent)); + mode.isCompiled = true; + let keywordPattern = null; + if (typeof mode.keywords === "object" && mode.keywords.$pattern) { + mode.keywords = Object.assign({}, mode.keywords); + keywordPattern = mode.keywords.$pattern; + delete mode.keywords.$pattern; + } + keywordPattern = keywordPattern || /\w+/; + if (mode.keywords) { + mode.keywords = compileKeywords(mode.keywords, language.case_insensitive); + } + cmode.keywordPatternRe = langRe(keywordPattern, true); + if (parent) { + if (!mode.begin) + mode.begin = /\B|\b/; + cmode.beginRe = langRe(cmode.begin); + if (!mode.end && !mode.endsWithParent) + mode.end = /\B|\b/; + if (mode.end) + cmode.endRe = langRe(cmode.end); + cmode.terminatorEnd = source(cmode.end) || ""; + if (mode.endsWithParent && parent.terminatorEnd) { + cmode.terminatorEnd += (mode.end ? "|" : "") + parent.terminatorEnd; + } + } + if (mode.illegal) + cmode.illegalRe = langRe(mode.illegal); + if (!mode.contains) + mode.contains = []; + mode.contains = [].concat(...mode.contains.map(function(c) { + return expandOrCloneMode(c === "self" ? mode : c); + })); + mode.contains.forEach(function(c) { + compileMode(c, cmode); + }); + if (mode.starts) { + compileMode(mode.starts, parent); + } + cmode.matcher = buildModeRegex(cmode); + return cmode; + } + if (!language.compilerExtensions) + language.compilerExtensions = []; + if (language.contains && language.contains.includes("self")) { + throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation."); + } + language.classNameAliases = inherit$1(language.classNameAliases || {}); + return compileMode(language); + } + function dependencyOnParent(mode) { + if (!mode) + return false; + return mode.endsWithParent || dependencyOnParent(mode.starts); + } + function expandOrCloneMode(mode) { + if (mode.variants && !mode.cachedVariants) { + mode.cachedVariants = mode.variants.map(function(variant) { + return inherit$1(mode, { variants: null }, variant); + }); + } + if (mode.cachedVariants) { + return mode.cachedVariants; + } + if (dependencyOnParent(mode)) { + return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null }); + } + if (Object.isFrozen(mode)) { + return inherit$1(mode); + } + return mode; + } + var version = "11.11.1"; + + class HTMLInjectionError extends Error { + constructor(reason, html) { + super(reason); + this.name = "HTMLInjectionError"; + this.html = html; + } + } + var escape = escapeHTML; + var inherit = inherit$1; + var NO_MATCH = Symbol("nomatch"); + var MAX_KEYWORD_HITS = 7; + var HLJS = function(hljs) { + const languages = Object.create(null); + const aliases = Object.create(null); + const plugins = []; + let SAFE_MODE = true; + const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?"; + const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: "Plain text", contains: [] }; + let options = { + ignoreUnescapedHTML: false, + throwUnescapedHTML: false, + noHighlightRe: /^(no-?highlight)$/i, + languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i, + classPrefix: "hljs-", + cssSelector: "pre code", + languages: null, + __emitter: TokenTreeEmitter + }; + function shouldNotHighlight(languageName) { + return options.noHighlightRe.test(languageName); + } + function blockLanguage(block) { + let classes = block.className + " "; + classes += block.parentNode ? block.parentNode.className : ""; + const match = options.languageDetectRe.exec(classes); + if (match) { + const language = getLanguage(match[1]); + if (!language) { + warn(LANGUAGE_NOT_FOUND.replace("{}", match[1])); + warn("Falling back to no-highlight mode for this block.", block); + } + return language ? match[1] : "no-highlight"; + } + return classes.split(/\s+/).find((_class) => shouldNotHighlight(_class) || getLanguage(_class)); + } + function highlight2(codeOrLanguageName, optionsOrCode, ignoreIllegals) { + let code = ""; + let languageName = ""; + if (typeof optionsOrCode === "object") { + code = codeOrLanguageName; + ignoreIllegals = optionsOrCode.ignoreIllegals; + languageName = optionsOrCode.language; + } else { + deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated."); + deprecated("10.7.0", `Please use highlight(code, options) instead. +https://github.com/highlightjs/highlight.js/issues/2277`); + languageName = codeOrLanguageName; + code = optionsOrCode; + } + if (ignoreIllegals === undefined) { + ignoreIllegals = true; + } + const context = { + code, + language: languageName + }; + fire("before:highlight", context); + const result = context.result ? context.result : _highlight(context.language, context.code, ignoreIllegals); + result.code = context.code; + fire("after:highlight", result); + return result; + } + function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) { + const keywordHits = Object.create(null); + function keywordData(mode, matchText) { + return mode.keywords[matchText]; + } + function processKeywords() { + if (!top.keywords) { + emitter.addText(modeBuffer); + return; + } + let lastIndex = 0; + top.keywordPatternRe.lastIndex = 0; + let match = top.keywordPatternRe.exec(modeBuffer); + let buf = ""; + while (match) { + buf += modeBuffer.substring(lastIndex, match.index); + const word = language.case_insensitive ? match[0].toLowerCase() : match[0]; + const data = keywordData(top, word); + if (data) { + const [kind, keywordRelevance] = data; + emitter.addText(buf); + buf = ""; + keywordHits[word] = (keywordHits[word] || 0) + 1; + if (keywordHits[word] <= MAX_KEYWORD_HITS) + relevance += keywordRelevance; + if (kind.startsWith("_")) { + buf += match[0]; + } else { + const cssClass = language.classNameAliases[kind] || kind; + emitKeyword(match[0], cssClass); + } + } else { + buf += match[0]; + } + lastIndex = top.keywordPatternRe.lastIndex; + match = top.keywordPatternRe.exec(modeBuffer); + } + buf += modeBuffer.substring(lastIndex); + emitter.addText(buf); + } + function processSubLanguage() { + if (modeBuffer === "") + return; + let result2 = null; + if (typeof top.subLanguage === "string") { + if (!languages[top.subLanguage]) { + emitter.addText(modeBuffer); + return; + } + result2 = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]); + continuations[top.subLanguage] = result2._top; + } else { + result2 = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null); + } + if (top.relevance > 0) { + relevance += result2.relevance; + } + emitter.__addSublanguage(result2._emitter, result2.language); + } + function processBuffer() { + if (top.subLanguage != null) { + processSubLanguage(); + } else { + processKeywords(); + } + modeBuffer = ""; + } + function emitKeyword(keyword, scope) { + if (keyword === "") + return; + emitter.startScope(scope); + emitter.addText(keyword); + emitter.endScope(); + } + function emitMultiClass(scope, match) { + let i = 1; + const max = match.length - 1; + while (i <= max) { + if (!scope._emit[i]) { + i++; + continue; + } + const klass = language.classNameAliases[scope[i]] || scope[i]; + const text = match[i]; + if (klass) { + emitKeyword(text, klass); + } else { + modeBuffer = text; + processKeywords(); + modeBuffer = ""; + } + i++; + } + } + function startNewMode(mode, match) { + if (mode.scope && typeof mode.scope === "string") { + emitter.openNode(language.classNameAliases[mode.scope] || mode.scope); + } + if (mode.beginScope) { + if (mode.beginScope._wrap) { + emitKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap); + modeBuffer = ""; + } else if (mode.beginScope._multi) { + emitMultiClass(mode.beginScope, match); + modeBuffer = ""; + } + } + top = Object.create(mode, { parent: { value: top } }); + return top; + } + function endOfMode(mode, match, matchPlusRemainder) { + let matched = startsWith(mode.endRe, matchPlusRemainder); + if (matched) { + if (mode["on:end"]) { + const resp = new Response(mode); + mode["on:end"](match, resp); + if (resp.isMatchIgnored) + matched = false; + } + if (matched) { + while (mode.endsParent && mode.parent) { + mode = mode.parent; + } + return mode; + } + } + if (mode.endsWithParent) { + return endOfMode(mode.parent, match, matchPlusRemainder); + } + } + function doIgnore(lexeme) { + if (top.matcher.regexIndex === 0) { + modeBuffer += lexeme[0]; + return 1; + } else { + resumeScanAtSamePosition = true; + return 0; + } + } + function doBeginMatch(match) { + const lexeme = match[0]; + const newMode = match.rule; + const resp = new Response(newMode); + const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]]; + for (const cb of beforeCallbacks) { + if (!cb) + continue; + cb(match, resp); + if (resp.isMatchIgnored) + return doIgnore(lexeme); + } + if (newMode.skip) { + modeBuffer += lexeme; + } else { + if (newMode.excludeBegin) { + modeBuffer += lexeme; + } + processBuffer(); + if (!newMode.returnBegin && !newMode.excludeBegin) { + modeBuffer = lexeme; + } + } + startNewMode(newMode, match); + return newMode.returnBegin ? 0 : lexeme.length; + } + function doEndMatch(match) { + const lexeme = match[0]; + const matchPlusRemainder = codeToHighlight.substring(match.index); + const endMode = endOfMode(top, match, matchPlusRemainder); + if (!endMode) { + return NO_MATCH; + } + const origin = top; + if (top.endScope && top.endScope._wrap) { + processBuffer(); + emitKeyword(lexeme, top.endScope._wrap); + } else if (top.endScope && top.endScope._multi) { + processBuffer(); + emitMultiClass(top.endScope, match); + } else if (origin.skip) { + modeBuffer += lexeme; + } else { + if (!(origin.returnEnd || origin.excludeEnd)) { + modeBuffer += lexeme; + } + processBuffer(); + if (origin.excludeEnd) { + modeBuffer = lexeme; + } + } + do { + if (top.scope) { + emitter.closeNode(); + } + if (!top.skip && !top.subLanguage) { + relevance += top.relevance; + } + top = top.parent; + } while (top !== endMode.parent); + if (endMode.starts) { + startNewMode(endMode.starts, match); + } + return origin.returnEnd ? 0 : lexeme.length; + } + function processContinuations() { + const list = []; + for (let current = top;current !== language; current = current.parent) { + if (current.scope) { + list.unshift(current.scope); + } + } + list.forEach((item) => emitter.openNode(item)); + } + let lastMatch = {}; + function processLexeme(textBeforeMatch, match) { + const lexeme = match && match[0]; + modeBuffer += textBeforeMatch; + if (lexeme == null) { + processBuffer(); + return 0; + } + if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") { + modeBuffer += codeToHighlight.slice(match.index, match.index + 1); + if (!SAFE_MODE) { + const err = new Error(`0 width match regex (${languageName})`); + err.languageName = languageName; + err.badRule = lastMatch.rule; + throw err; + } + return 1; + } + lastMatch = match; + if (match.type === "begin") { + return doBeginMatch(match); + } else if (match.type === "illegal" && !ignoreIllegals) { + const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || "") + '"'); + err.mode = top; + throw err; + } else if (match.type === "end") { + const processed = doEndMatch(match); + if (processed !== NO_MATCH) { + return processed; + } + } + if (match.type === "illegal" && lexeme === "") { + modeBuffer += ` +`; + return 1; + } + if (iterations > 1e5 && iterations > match.index * 3) { + const err = new Error("potential infinite loop, way more iterations than matches"); + throw err; + } + modeBuffer += lexeme; + return lexeme.length; + } + const language = getLanguage(languageName); + if (!language) { + error(LANGUAGE_NOT_FOUND.replace("{}", languageName)); + throw new Error('Unknown language: "' + languageName + '"'); + } + const md = compileLanguage(language); + let result = ""; + let top = continuation || md; + const continuations = {}; + const emitter = new options.__emitter(options); + processContinuations(); + let modeBuffer = ""; + let relevance = 0; + let index = 0; + let iterations = 0; + let resumeScanAtSamePosition = false; + try { + if (!language.__emitTokens) { + top.matcher.considerAll(); + for (;; ) { + iterations++; + if (resumeScanAtSamePosition) { + resumeScanAtSamePosition = false; + } else { + top.matcher.considerAll(); + } + top.matcher.lastIndex = index; + const match = top.matcher.exec(codeToHighlight); + if (!match) + break; + const beforeMatch = codeToHighlight.substring(index, match.index); + const processedCount = processLexeme(beforeMatch, match); + index = match.index + processedCount; + } + processLexeme(codeToHighlight.substring(index)); + } else { + language.__emitTokens(codeToHighlight, emitter); + } + emitter.finalize(); + result = emitter.toHTML(); + return { + language: languageName, + value: result, + relevance, + illegal: false, + _emitter: emitter, + _top: top + }; + } catch (err) { + if (err.message && err.message.includes("Illegal")) { + return { + language: languageName, + value: escape(codeToHighlight), + illegal: true, + relevance: 0, + _illegalBy: { + message: err.message, + index, + context: codeToHighlight.slice(index - 100, index + 100), + mode: err.mode, + resultSoFar: result + }, + _emitter: emitter + }; + } else if (SAFE_MODE) { + return { + language: languageName, + value: escape(codeToHighlight), + illegal: false, + relevance: 0, + errorRaised: err, + _emitter: emitter, + _top: top + }; + } else { + throw err; + } + } + } + function justTextHighlightResult(code) { + const result = { + value: escape(code), + illegal: false, + relevance: 0, + _top: PLAINTEXT_LANGUAGE, + _emitter: new options.__emitter(options) + }; + result._emitter.addText(code); + return result; + } + function highlightAuto(code, languageSubset) { + languageSubset = languageSubset || options.languages || Object.keys(languages); + const plaintext = justTextHighlightResult(code); + const results = languageSubset.filter(getLanguage).filter(autoDetection).map((name) => _highlight(name, code, false)); + results.unshift(plaintext); + const sorted = results.sort((a, b2) => { + if (a.relevance !== b2.relevance) + return b2.relevance - a.relevance; + if (a.language && b2.language) { + if (getLanguage(a.language).supersetOf === b2.language) { + return 1; + } else if (getLanguage(b2.language).supersetOf === a.language) { + return -1; + } + } + return 0; + }); + const [best, secondBest] = sorted; + const result = best; + result.secondBest = secondBest; + return result; + } + function updateClassName(element, currentLang, resultLang) { + const language = currentLang && aliases[currentLang] || resultLang; + element.classList.add("hljs"); + element.classList.add(`language-${language}`); + } + function highlightElement(element) { + let node = null; + const language = blockLanguage(element); + if (shouldNotHighlight(language)) + return; + fire("before:highlightElement", { el: element, language }); + if (element.dataset.highlighted) { + console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", element); + return; + } + if (element.children.length > 0) { + if (!options.ignoreUnescapedHTML) { + console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."); + console.warn("https://github.com/highlightjs/highlight.js/wiki/security"); + console.warn("The element with unescaped HTML:"); + console.warn(element); + } + if (options.throwUnescapedHTML) { + const err = new HTMLInjectionError("One of your code blocks includes unescaped HTML.", element.innerHTML); + throw err; + } + } + node = element; + const text = node.textContent; + const result = language ? highlight2(text, { language, ignoreIllegals: true }) : highlightAuto(text); + element.innerHTML = result.value; + element.dataset.highlighted = "yes"; + updateClassName(element, language, result.language); + element.result = { + language: result.language, + re: result.relevance, + relevance: result.relevance + }; + if (result.secondBest) { + element.secondBest = { + language: result.secondBest.language, + relevance: result.secondBest.relevance + }; + } + fire("after:highlightElement", { el: element, result, text }); + } + function configure(userOptions) { + options = inherit(options, userOptions); + } + const initHighlighting = () => { + highlightAll(); + deprecated("10.6.0", "initHighlighting() deprecated. Use highlightAll() now."); + }; + function initHighlightingOnLoad() { + highlightAll(); + deprecated("10.6.0", "initHighlightingOnLoad() deprecated. Use highlightAll() now."); + } + let wantsHighlight = false; + function highlightAll() { + function boot() { + highlightAll(); + } + if (document.readyState === "loading") { + if (!wantsHighlight) { + window.addEventListener("DOMContentLoaded", boot, false); + } + wantsHighlight = true; + return; + } + const blocks = document.querySelectorAll(options.cssSelector); + blocks.forEach(highlightElement); + } + function registerLanguage(languageName, languageDefinition) { + let lang = null; + try { + lang = languageDefinition(hljs); + } catch (error$1) { + error("Language definition for '{}' could not be registered.".replace("{}", languageName)); + if (!SAFE_MODE) { + throw error$1; + } else { + error(error$1); + } + lang = PLAINTEXT_LANGUAGE; + } + if (!lang.name) + lang.name = languageName; + languages[languageName] = lang; + lang.rawDefinition = languageDefinition.bind(null, hljs); + if (lang.aliases) { + registerAliases(lang.aliases, { languageName }); + } + } + function unregisterLanguage(languageName) { + delete languages[languageName]; + for (const alias of Object.keys(aliases)) { + if (aliases[alias] === languageName) { + delete aliases[alias]; + } + } + } + function listLanguages() { + return Object.keys(languages); + } + function getLanguage(name) { + name = (name || "").toLowerCase(); + return languages[name] || languages[aliases[name]]; + } + function registerAliases(aliasList, { languageName }) { + if (typeof aliasList === "string") { + aliasList = [aliasList]; + } + aliasList.forEach((alias) => { + aliases[alias.toLowerCase()] = languageName; + }); + } + function autoDetection(name) { + const lang = getLanguage(name); + return lang && !lang.disableAutodetect; + } + function upgradePluginAPI(plugin) { + if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) { + plugin["before:highlightElement"] = (data) => { + plugin["before:highlightBlock"](Object.assign({ block: data.el }, data)); + }; + } + if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) { + plugin["after:highlightElement"] = (data) => { + plugin["after:highlightBlock"](Object.assign({ block: data.el }, data)); + }; + } + } + function addPlugin(plugin) { + upgradePluginAPI(plugin); + plugins.push(plugin); + } + function removePlugin(plugin) { + const index = plugins.indexOf(plugin); + if (index !== -1) { + plugins.splice(index, 1); + } + } + function fire(event, args) { + const cb = event; + plugins.forEach(function(plugin) { + if (plugin[cb]) { + plugin[cb](args); + } + }); + } + function deprecateHighlightBlock(el) { + deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0"); + deprecated("10.7.0", "Please use highlightElement now."); + return highlightElement(el); + } + Object.assign(hljs, { + highlight: highlight2, + highlightAuto, + highlightAll, + highlightElement, + highlightBlock: deprecateHighlightBlock, + configure, + initHighlighting, + initHighlightingOnLoad, + registerLanguage, + unregisterLanguage, + listLanguages, + getLanguage, + registerAliases, + autoDetection, + inherit, + addPlugin, + removePlugin + }); + hljs.debugMode = function() { + SAFE_MODE = false; + }; + hljs.safeMode = function() { + SAFE_MODE = true; + }; + hljs.versionString = version; + hljs.regex = { + concat, + lookahead, + either, + optional, + anyNumberOfTimes + }; + for (const key in MODES) { + if (typeof MODES[key] === "object") { + deepFreeze(MODES[key]); + } + } + Object.assign(hljs, MODES); + return hljs; + }; + var highlight = HLJS({}); + highlight.newInstance = () => HLJS({}); + module.exports = highlight; + highlight.HighlightJS = highlight; + highlight.default = highlight; + }); + + // node_modules/marked/lib/marked.esm.js + function M() { + return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null }; + } + var T = M(); + function G(u) { + T = u; + } + var _ = { exec: () => null }; + function k(u, e = "") { + let t = typeof u == "string" ? u : u.source, n = { replace: (r, i) => { + let s = typeof i == "string" ? i : i.source; + return s = s.replace(m.caret, "$1"), t = t.replace(r, s), n; + }, getRegex: () => new RegExp(t, e) }; + return n; + } + var Re = (() => { + try { + return !!new RegExp("(?<=1)(?/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] +\S/, listReplaceTask: /^\[[ xX]\] +/, listTaskCheckbox: /\[[ xX]\]/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: (u) => new RegExp(`^( {0,3}${u})((?:[ ][^\\n]*)?(?:\\n|$))`), nextBulletRegex: (u) => new RegExp(`^ {0,${Math.min(3, u - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`), hrRegex: (u) => new RegExp(`^ {0,${Math.min(3, u - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), fencesBeginRegex: (u) => new RegExp(`^ {0,${Math.min(3, u - 1)}}(?:\`\`\`|~~~)`), headingBeginRegex: (u) => new RegExp(`^ {0,${Math.min(3, u - 1)}}#`), htmlBeginRegex: (u) => new RegExp(`^ {0,${Math.min(3, u - 1)}}<(?:[a-z].*>|!--)`, "i"), blockquoteBeginRegex: (u) => new RegExp(`^ {0,${Math.min(3, u - 1)}}>`) }; + var Te = /^(?:[ \t]*(?:\n|$))+/; + var Oe = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/; + var we = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/; + var A = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/; + var ye = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/; + var N = / {0,3}(?:[*+-]|\d{1,9}[.)])/; + var re = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/; + var se = k(re).replace(/bull/g, N).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex(); + var Pe = k(re).replace(/bull/g, N).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex(); + var Q = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/; + var Se = /^[^\n]+/; + var j = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/; + var $e = k(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", j).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(); + var _e = k(/^(bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, N).getRegex(); + var q = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul"; + var F = /|$))/; + var Le = k("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|\\n*|$)|\\n*|$)|)[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$))", "i").replace("comment", F).replace("tag", q).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(); + var ie = k(Q).replace("hr", A).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", q).getRegex(); + var Me = k(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", ie).getRegex(); + var U = { blockquote: Me, code: Oe, def: $e, fences: we, heading: ye, hr: A, html: Le, lheading: se, list: _e, newline: Te, paragraph: ie, table: _, text: Se }; + var te = k("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", A).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}\t)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", q).getRegex(); + var ze = { ...U, lheading: Pe, table: te, paragraph: k(Q).replace("hr", A).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", te).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", q).getRegex() }; + var Ee = { ...U, html: k(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", F).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: _, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: k(Q).replace("hr", A).replace("heading", ` *#{1,6} *[^ +]`).replace("lheading", se).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() }; + var Ie = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/; + var Ae = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/; + var oe = /^( {2,}|\\)\n(?!\s*$)/; + var Ce = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\`+)[^`]+\k(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-", Re ? "(?`+)[^`]+\k(?!`)/).replace("html", /<(?! )[^<>]*?>/).getRegex(); + var pe = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/; + var Ze = k(pe, "u").replace(/punct/g, v).getRegex(); + var Ne = k(pe, "u").replace(/punct/g, le).getRegex(); + var ce = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)"; + var Qe = k(ce, "gu").replace(/notPunctSpace/g, ae).replace(/punctSpace/g, K).replace(/punct/g, v).getRegex(); + var je = k(ce, "gu").replace(/notPunctSpace/g, qe).replace(/punctSpace/g, De).replace(/punct/g, le).getRegex(); + var Fe = k("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, ae).replace(/punctSpace/g, K).replace(/punct/g, v).getRegex(); + var Ue = k(/^~~?(?:((?!~)punct)|[^\s~])/, "u").replace(/punct/g, ue).getRegex(); + var Ke = "^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)"; + var We = k(Ke, "gu").replace(/notPunctSpace/g, He).replace(/punctSpace/g, ve).replace(/punct/g, ue).getRegex(); + var Xe = k(/\\(punct)/, "gu").replace(/punct/g, v).getRegex(); + var Je = k(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(); + var Ve = k(F).replace("(?:-->|$)", "-->").getRegex(); + var Ye = k("^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^").replace("comment", Ve).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(); + var D = /(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+[^`]*?`+(?!`)|[^\[\]\\`])*?/; + var et = k(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace("label", D).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(); + var he = k(/^!?\[(label)\]\[(ref)\]/).replace("label", D).replace("ref", j).getRegex(); + var ke = k(/^!?\[(ref)\](?:\[\])?/).replace("ref", j).getRegex(); + var tt = k("reflink|nolink(?!\\()", "g").replace("reflink", he).replace("nolink", ke).getRegex(); + var ne = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/; + var W = { _backpedal: _, anyPunctuation: Xe, autolink: Je, blockSkip: Ge, br: oe, code: Ae, del: _, delLDelim: _, delRDelim: _, emStrongLDelim: Ze, emStrongRDelimAst: Qe, emStrongRDelimUnd: Fe, escape: Ie, link: et, nolink: ke, punctuation: Be, reflink: he, reflinkSearch: tt, tag: Ye, text: Ce, url: _ }; + var nt = { ...W, link: k(/^!?\[(label)\]\((.*?)\)/).replace("label", D).getRegex(), reflink: k(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", D).getRegex() }; + var Z = { ...W, emStrongRDelimAst: je, emStrongLDelim: Ne, delLDelim: Ue, delRDelim: We, url: k(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol", ne).replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: k(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\": ">", '"': """, "'": "'" }; + var de = (u) => st[u]; + function O(u, e) { + if (e) { + if (m.escapeTest.test(u)) + return u.replace(m.escapeReplace, de); + } else if (m.escapeTestNoEncode.test(u)) + return u.replace(m.escapeReplaceNoEncode, de); + return u; + } + function X(u) { + try { + u = encodeURI(u).replace(m.percentDecode, "%"); + } catch { + return null; + } + return u; + } + function J(u, e) { + let t = u.replace(m.findPipe, (i, s, a) => { + let o = false, l = s; + for (;--l >= 0 && a[l] === "\\"; ) + o = !o; + return o ? "|" : " |"; + }), n = t.split(m.splitPipe), r = 0; + if (n[0].trim() || n.shift(), n.length > 0 && !n.at(-1)?.trim() && n.pop(), e) + if (n.length > e) + n.splice(e); + else + for (;n.length < e; ) + n.push(""); + for (;r < n.length; r++) + n[r] = n[r].trim().replace(m.slashPipe, "|"); + return n; + } + function E(u, e, t) { + let n = u.length; + if (n === 0) + return ""; + let r = 0; + for (;r < n; ) { + let i = u.charAt(n - r - 1); + if (i === e && !t) + r++; + else if (i !== e && t) + r++; + else + break; + } + return u.slice(0, n - r); + } + function ge(u, e) { + if (u.indexOf(e[1]) === -1) + return -1; + let t = 0; + for (let n = 0;n < u.length; n++) + if (u[n] === "\\") + n++; + else if (u[n] === e[0]) + t++; + else if (u[n] === e[1] && (t--, t < 0)) + return n; + return t > 0 ? -2 : -1; + } + function fe(u, e = 0) { + let t = e, n = ""; + for (let r of u) + if (r === "\t") { + let i = 4 - t % 4; + n += " ".repeat(i), t += i; + } else + n += r, t++; + return n; + } + function me(u, e, t, n, r) { + let i = e.href, s = e.title || null, a = u[1].replace(r.other.outputLinkReplace, "$1"); + n.state.inLink = true; + let o = { type: u[0].charAt(0) === "!" ? "image" : "link", raw: t, href: i, title: s, text: a, tokens: n.inlineTokens(a) }; + return n.state.inLink = false, o; + } + function it(u, e, t) { + let n = u.match(t.other.indentCodeCompensation); + if (n === null) + return e; + let r = n[1]; + return e.split(` +`).map((i) => { + let s = i.match(t.other.beginningSpace); + if (s === null) + return i; + let [a] = s; + return a.length >= r.length ? i.slice(r.length) : i; + }).join(` +`); + } + var w = class { + options; + rules; + lexer; + constructor(e) { + this.options = e || T; + } + space(e) { + let t = this.rules.block.newline.exec(e); + if (t && t[0].length > 0) + return { type: "space", raw: t[0] }; + } + code(e) { + let t = this.rules.block.code.exec(e); + if (t) { + let n = t[0].replace(this.rules.other.codeRemoveIndent, ""); + return { type: "code", raw: t[0], codeBlockStyle: "indented", text: this.options.pedantic ? n : E(n, ` +`) }; + } + } + fences(e) { + let t = this.rules.block.fences.exec(e); + if (t) { + let n = t[0], r = it(n, t[3] || "", this.rules); + return { type: "code", raw: n, lang: t[2] ? t[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : t[2], text: r }; + } + } + heading(e) { + let t = this.rules.block.heading.exec(e); + if (t) { + let n = t[2].trim(); + if (this.rules.other.endingHash.test(n)) { + let r = E(n, "#"); + (this.options.pedantic || !r || this.rules.other.endingSpaceChar.test(r)) && (n = r.trim()); + } + return { type: "heading", raw: t[0], depth: t[1].length, text: n, tokens: this.lexer.inline(n) }; + } + } + hr(e) { + let t = this.rules.block.hr.exec(e); + if (t) + return { type: "hr", raw: E(t[0], ` +`) }; + } + blockquote(e) { + let t = this.rules.block.blockquote.exec(e); + if (t) { + let n = E(t[0], ` +`).split(` +`), r = "", i = "", s = []; + for (;n.length > 0; ) { + let a = false, o = [], l; + for (l = 0;l < n.length; l++) + if (this.rules.other.blockquoteStart.test(n[l])) + o.push(n[l]), a = true; + else if (!a) + o.push(n[l]); + else + break; + n = n.slice(l); + let p = o.join(` +`), c = p.replace(this.rules.other.blockquoteSetextReplace, ` + $1`).replace(this.rules.other.blockquoteSetextReplace2, ""); + r = r ? `${r} +${p}` : p, i = i ? `${i} +${c}` : c; + let d = this.lexer.state.top; + if (this.lexer.state.top = true, this.lexer.blockTokens(c, s, true), this.lexer.state.top = d, n.length === 0) + break; + let h = s.at(-1); + if (h?.type === "code") + break; + if (h?.type === "blockquote") { + let R = h, f = R.raw + ` +` + n.join(` +`), S = this.blockquote(f); + s[s.length - 1] = S, r = r.substring(0, r.length - R.raw.length) + S.raw, i = i.substring(0, i.length - R.text.length) + S.text; + break; + } else if (h?.type === "list") { + let R = h, f = R.raw + ` +` + n.join(` +`), S = this.list(f); + s[s.length - 1] = S, r = r.substring(0, r.length - h.raw.length) + S.raw, i = i.substring(0, i.length - R.raw.length) + S.raw, n = f.substring(s.at(-1).raw.length).split(` +`); + continue; + } + } + return { type: "blockquote", raw: r, tokens: s, text: i }; + } + } + list(e) { + let t = this.rules.block.list.exec(e); + if (t) { + let n = t[1].trim(), r = n.length > 1, i = { type: "list", raw: "", ordered: r, start: r ? +n.slice(0, -1) : "", loose: false, items: [] }; + n = r ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = r ? n : "[*+-]"); + let s = this.rules.other.listItemRegex(n), a = false; + for (;e; ) { + let l = false, p = "", c = ""; + if (!(t = s.exec(e)) || this.rules.block.hr.test(e)) + break; + p = t[0], e = e.substring(p.length); + let d = fe(t[2].split(` +`, 1)[0], t[1].length), h = e.split(` +`, 1)[0], R = !d.trim(), f = 0; + if (this.options.pedantic ? (f = 2, c = d.trimStart()) : R ? f = t[1].length + 1 : (f = d.search(this.rules.other.nonSpaceChar), f = f > 4 ? 1 : f, c = d.slice(f), f += t[1].length), R && this.rules.other.blankLine.test(h) && (p += h + ` +`, e = e.substring(h.length + 1), l = true), !l) { + let S = this.rules.other.nextBulletRegex(f), V = this.rules.other.hrRegex(f), Y = this.rules.other.fencesBeginRegex(f), ee = this.rules.other.headingBeginRegex(f), xe = this.rules.other.htmlBeginRegex(f), be = this.rules.other.blockquoteBeginRegex(f); + for (;e; ) { + let H = e.split(` +`, 1)[0], I; + if (h = H, this.options.pedantic ? (h = h.replace(this.rules.other.listReplaceNesting, " "), I = h) : I = h.replace(this.rules.other.tabCharGlobal, " "), Y.test(h) || ee.test(h) || xe.test(h) || be.test(h) || S.test(h) || V.test(h)) + break; + if (I.search(this.rules.other.nonSpaceChar) >= f || !h.trim()) + c += ` +` + I.slice(f); + else { + if (R || d.replace(this.rules.other.tabCharGlobal, " ").search(this.rules.other.nonSpaceChar) >= 4 || Y.test(d) || ee.test(d) || V.test(d)) + break; + c += ` +` + h; + } + R = !h.trim(), p += H + ` +`, e = e.substring(H.length + 1), d = I.slice(f); + } + } + i.loose || (a ? i.loose = true : this.rules.other.doubleBlankLine.test(p) && (a = true)), i.items.push({ type: "list_item", raw: p, task: !!this.options.gfm && this.rules.other.listIsTask.test(c), loose: false, text: c, tokens: [] }), i.raw += p; + } + let o = i.items.at(-1); + if (o) + o.raw = o.raw.trimEnd(), o.text = o.text.trimEnd(); + else + return; + i.raw = i.raw.trimEnd(); + for (let l of i.items) { + if (this.lexer.state.top = false, l.tokens = this.lexer.blockTokens(l.text, []), l.task) { + if (l.text = l.text.replace(this.rules.other.listReplaceTask, ""), l.tokens[0]?.type === "text" || l.tokens[0]?.type === "paragraph") { + l.tokens[0].raw = l.tokens[0].raw.replace(this.rules.other.listReplaceTask, ""), l.tokens[0].text = l.tokens[0].text.replace(this.rules.other.listReplaceTask, ""); + for (let c = this.lexer.inlineQueue.length - 1;c >= 0; c--) + if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[c].src)) { + this.lexer.inlineQueue[c].src = this.lexer.inlineQueue[c].src.replace(this.rules.other.listReplaceTask, ""); + break; + } + } + let p = this.rules.other.listTaskCheckbox.exec(l.raw); + if (p) { + let c = { type: "checkbox", raw: p[0] + " ", checked: p[0] !== "[ ]" }; + l.checked = c.checked, i.loose ? l.tokens[0] && ["paragraph", "text"].includes(l.tokens[0].type) && "tokens" in l.tokens[0] && l.tokens[0].tokens ? (l.tokens[0].raw = c.raw + l.tokens[0].raw, l.tokens[0].text = c.raw + l.tokens[0].text, l.tokens[0].tokens.unshift(c)) : l.tokens.unshift({ type: "paragraph", raw: c.raw, text: c.raw, tokens: [c] }) : l.tokens.unshift(c); + } + } + if (!i.loose) { + let p = l.tokens.filter((d) => d.type === "space"), c = p.length > 0 && p.some((d) => this.rules.other.anyLine.test(d.raw)); + i.loose = c; + } + } + if (i.loose) + for (let l of i.items) { + l.loose = true; + for (let p of l.tokens) + p.type === "text" && (p.type = "paragraph"); + } + return i; + } + } + html(e) { + let t = this.rules.block.html.exec(e); + if (t) + return { type: "html", block: true, raw: t[0], pre: t[1] === "pre" || t[1] === "script" || t[1] === "style", text: t[0] }; + } + def(e) { + let t = this.rules.block.def.exec(e); + if (t) { + let n = t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "), r = t[2] ? t[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", i = t[3] ? t[3].substring(1, t[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t[3]; + return { type: "def", tag: n, raw: t[0], href: r, title: i }; + } + } + table(e) { + let t = this.rules.block.table.exec(e); + if (!t || !this.rules.other.tableDelimiter.test(t[2])) + return; + let n = J(t[1]), r = t[2].replace(this.rules.other.tableAlignChars, "").split("|"), i = t[3]?.trim() ? t[3].replace(this.rules.other.tableRowBlankLine, "").split(` +`) : [], s = { type: "table", raw: t[0], header: [], align: [], rows: [] }; + if (n.length === r.length) { + for (let a of r) + this.rules.other.tableAlignRight.test(a) ? s.align.push("right") : this.rules.other.tableAlignCenter.test(a) ? s.align.push("center") : this.rules.other.tableAlignLeft.test(a) ? s.align.push("left") : s.align.push(null); + for (let a = 0;a < n.length; a++) + s.header.push({ text: n[a], tokens: this.lexer.inline(n[a]), header: true, align: s.align[a] }); + for (let a of i) + s.rows.push(J(a, s.header.length).map((o, l) => ({ text: o, tokens: this.lexer.inline(o), header: false, align: s.align[l] }))); + return s; + } + } + lheading(e) { + let t = this.rules.block.lheading.exec(e); + if (t) + return { type: "heading", raw: t[0], depth: t[2].charAt(0) === "=" ? 1 : 2, text: t[1], tokens: this.lexer.inline(t[1]) }; + } + paragraph(e) { + let t = this.rules.block.paragraph.exec(e); + if (t) { + let n = t[1].charAt(t[1].length - 1) === ` +` ? t[1].slice(0, -1) : t[1]; + return { type: "paragraph", raw: t[0], text: n, tokens: this.lexer.inline(n) }; + } + } + text(e) { + let t = this.rules.block.text.exec(e); + if (t) + return { type: "text", raw: t[0], text: t[0], tokens: this.lexer.inline(t[0]) }; + } + escape(e) { + let t = this.rules.inline.escape.exec(e); + if (t) + return { type: "escape", raw: t[0], text: t[1] }; + } + tag(e) { + let t = this.rules.inline.tag.exec(e); + if (t) + return !this.lexer.state.inLink && this.rules.other.startATag.test(t[0]) ? this.lexer.state.inLink = true : this.lexer.state.inLink && this.rules.other.endATag.test(t[0]) && (this.lexer.state.inLink = false), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(t[0]) ? this.lexer.state.inRawBlock = true : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(t[0]) && (this.lexer.state.inRawBlock = false), { type: "html", raw: t[0], inLink: this.lexer.state.inLink, inRawBlock: this.lexer.state.inRawBlock, block: false, text: t[0] }; + } + link(e) { + let t = this.rules.inline.link.exec(e); + if (t) { + let n = t[2].trim(); + if (!this.options.pedantic && this.rules.other.startAngleBracket.test(n)) { + if (!this.rules.other.endAngleBracket.test(n)) + return; + let s = E(n.slice(0, -1), "\\"); + if ((n.length - s.length) % 2 === 0) + return; + } else { + let s = ge(t[2], "()"); + if (s === -2) + return; + if (s > -1) { + let o = (t[0].indexOf("!") === 0 ? 5 : 4) + t[1].length + s; + t[2] = t[2].substring(0, s), t[0] = t[0].substring(0, o).trim(), t[3] = ""; + } + } + let r = t[2], i = ""; + if (this.options.pedantic) { + let s = this.rules.other.pedanticHrefTitle.exec(r); + s && (r = s[1], i = s[3]); + } else + i = t[3] ? t[3].slice(1, -1) : ""; + return r = r.trim(), this.rules.other.startAngleBracket.test(r) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(n) ? r = r.slice(1) : r = r.slice(1, -1)), me(t, { href: r && r.replace(this.rules.inline.anyPunctuation, "$1"), title: i && i.replace(this.rules.inline.anyPunctuation, "$1") }, t[0], this.lexer, this.rules); + } + } + reflink(e, t) { + let n; + if ((n = this.rules.inline.reflink.exec(e)) || (n = this.rules.inline.nolink.exec(e))) { + let r = (n[2] || n[1]).replace(this.rules.other.multipleSpaceGlobal, " "), i = t[r.toLowerCase()]; + if (!i) { + let s = n[0].charAt(0); + return { type: "text", raw: s, text: s }; + } + return me(n, i, n[0], this.lexer, this.rules); + } + } + emStrong(e, t, n = "") { + let r = this.rules.inline.emStrongLDelim.exec(e); + if (!r || r[3] && n.match(this.rules.other.unicodeAlphaNumeric)) + return; + if (!(r[1] || r[2] || "") || !n || this.rules.inline.punctuation.exec(n)) { + let s = [...r[0]].length - 1, a, o, l = s, p = 0, c = r[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd; + for (c.lastIndex = 0, t = t.slice(-1 * e.length + s);(r = c.exec(t)) != null; ) { + if (a = r[1] || r[2] || r[3] || r[4] || r[5] || r[6], !a) + continue; + if (o = [...a].length, r[3] || r[4]) { + l += o; + continue; + } else if ((r[5] || r[6]) && s % 3 && !((s + o) % 3)) { + p += o; + continue; + } + if (l -= o, l > 0) + continue; + o = Math.min(o, o + l + p); + let d = [...r[0]][0].length, h = e.slice(0, s + r.index + d + o); + if (Math.min(s, o) % 2) { + let f = h.slice(1, -1); + return { type: "em", raw: h, text: f, tokens: this.lexer.inlineTokens(f) }; + } + let R = h.slice(2, -2); + return { type: "strong", raw: h, text: R, tokens: this.lexer.inlineTokens(R) }; + } + } + } + codespan(e) { + let t = this.rules.inline.code.exec(e); + if (t) { + let n = t[2].replace(this.rules.other.newLineCharGlobal, " "), r = this.rules.other.nonSpaceChar.test(n), i = this.rules.other.startingSpaceChar.test(n) && this.rules.other.endingSpaceChar.test(n); + return r && i && (n = n.substring(1, n.length - 1)), { type: "codespan", raw: t[0], text: n }; + } + } + br(e) { + let t = this.rules.inline.br.exec(e); + if (t) + return { type: "br", raw: t[0] }; + } + del(e, t, n = "") { + let r = this.rules.inline.delLDelim.exec(e); + if (!r) + return; + if (!(r[1] || "") || !n || this.rules.inline.punctuation.exec(n)) { + let s = [...r[0]].length - 1, a, o, l = s, p = this.rules.inline.delRDelim; + for (p.lastIndex = 0, t = t.slice(-1 * e.length + s);(r = p.exec(t)) != null; ) { + if (a = r[1] || r[2] || r[3] || r[4] || r[5] || r[6], !a || (o = [...a].length, o !== s)) + continue; + if (r[3] || r[4]) { + l += o; + continue; + } + if (l -= o, l > 0) + continue; + o = Math.min(o, o + l); + let c = [...r[0]][0].length, d = e.slice(0, s + r.index + c + o), h = d.slice(s, -s); + return { type: "del", raw: d, text: h, tokens: this.lexer.inlineTokens(h) }; + } + } + } + autolink(e) { + let t = this.rules.inline.autolink.exec(e); + if (t) { + let n, r; + return t[2] === "@" ? (n = t[1], r = "mailto:" + n) : (n = t[1], r = n), { type: "link", raw: t[0], text: n, href: r, tokens: [{ type: "text", raw: n, text: n }] }; + } + } + url(e) { + let t; + if (t = this.rules.inline.url.exec(e)) { + let n, r; + if (t[2] === "@") + n = t[0], r = "mailto:" + n; + else { + let i; + do + i = t[0], t[0] = this.rules.inline._backpedal.exec(t[0])?.[0] ?? ""; + while (i !== t[0]); + n = t[0], t[1] === "www." ? r = "http://" + t[0] : r = t[0]; + } + return { type: "link", raw: t[0], text: n, href: r, tokens: [{ type: "text", raw: n, text: n }] }; + } + } + inlineText(e) { + let t = this.rules.inline.text.exec(e); + if (t) { + let n = this.lexer.state.inRawBlock; + return { type: "text", raw: t[0], text: t[0], escaped: n }; + } + } + }; + var x = class u { + tokens; + options; + state; + inlineQueue; + tokenizer; + constructor(e) { + this.tokens = [], this.tokens.links = Object.create(null), this.options = e || T, this.options.tokenizer = this.options.tokenizer || new w, this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = { inLink: false, inRawBlock: false, top: true }; + let t = { other: m, block: C.normal, inline: z.normal }; + this.options.pedantic ? (t.block = C.pedantic, t.inline = z.pedantic) : this.options.gfm && (t.block = C.gfm, this.options.breaks ? t.inline = z.breaks : t.inline = z.gfm), this.tokenizer.rules = t; + } + static get rules() { + return { block: C, inline: z }; + } + static lex(e, t) { + return new u(t).lex(e); + } + static lexInline(e, t) { + return new u(t).inlineTokens(e); + } + lex(e) { + e = e.replace(m.carriageReturn, ` +`), this.blockTokens(e, this.tokens); + for (let t = 0;t < this.inlineQueue.length; t++) { + let n = this.inlineQueue[t]; + this.inlineTokens(n.src, n.tokens); + } + return this.inlineQueue = [], this.tokens; + } + blockTokens(e, t = [], n = false) { + for (this.options.pedantic && (e = e.replace(m.tabCharGlobal, " ").replace(m.spaceLine, ""));e; ) { + let r; + if (this.options.extensions?.block?.some((s) => (r = s.call({ lexer: this }, e, t)) ? (e = e.substring(r.raw.length), t.push(r), true) : false)) + continue; + if (r = this.tokenizer.space(e)) { + e = e.substring(r.raw.length); + let s = t.at(-1); + r.raw.length === 1 && s !== undefined ? s.raw += ` +` : t.push(r); + continue; + } + if (r = this.tokenizer.code(e)) { + e = e.substring(r.raw.length); + let s = t.at(-1); + s?.type === "paragraph" || s?.type === "text" ? (s.raw += (s.raw.endsWith(` +`) ? "" : ` +`) + r.raw, s.text += ` +` + r.text, this.inlineQueue.at(-1).src = s.text) : t.push(r); + continue; + } + if (r = this.tokenizer.fences(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.heading(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.hr(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.blockquote(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.list(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.html(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.def(e)) { + e = e.substring(r.raw.length); + let s = t.at(-1); + s?.type === "paragraph" || s?.type === "text" ? (s.raw += (s.raw.endsWith(` +`) ? "" : ` +`) + r.raw, s.text += ` +` + r.raw, this.inlineQueue.at(-1).src = s.text) : this.tokens.links[r.tag] || (this.tokens.links[r.tag] = { href: r.href, title: r.title }, t.push(r)); + continue; + } + if (r = this.tokenizer.table(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.lheading(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + let i = e; + if (this.options.extensions?.startBlock) { + let s = 1 / 0, a = e.slice(1), o; + this.options.extensions.startBlock.forEach((l) => { + o = l.call({ lexer: this }, a), typeof o == "number" && o >= 0 && (s = Math.min(s, o)); + }), s < 1 / 0 && s >= 0 && (i = e.substring(0, s + 1)); + } + if (this.state.top && (r = this.tokenizer.paragraph(i))) { + let s = t.at(-1); + n && s?.type === "paragraph" ? (s.raw += (s.raw.endsWith(` +`) ? "" : ` +`) + r.raw, s.text += ` +` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = s.text) : t.push(r), n = i.length !== e.length, e = e.substring(r.raw.length); + continue; + } + if (r = this.tokenizer.text(e)) { + e = e.substring(r.raw.length); + let s = t.at(-1); + s?.type === "text" ? (s.raw += (s.raw.endsWith(` +`) ? "" : ` +`) + r.raw, s.text += ` +` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = s.text) : t.push(r); + continue; + } + if (e) { + let s = "Infinite loop on byte: " + e.charCodeAt(0); + if (this.options.silent) { + console.error(s); + break; + } else + throw new Error(s); + } + } + return this.state.top = true, t; + } + inline(e, t = []) { + return this.inlineQueue.push({ src: e, tokens: t }), t; + } + inlineTokens(e, t = []) { + let n = e, r = null; + if (this.tokens.links) { + let o = Object.keys(this.tokens.links); + if (o.length > 0) + for (;(r = this.tokenizer.rules.inline.reflinkSearch.exec(n)) != null; ) + o.includes(r[0].slice(r[0].lastIndexOf("[") + 1, -1)) && (n = n.slice(0, r.index) + "[" + "a".repeat(r[0].length - 2) + "]" + n.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex)); + } + for (;(r = this.tokenizer.rules.inline.anyPunctuation.exec(n)) != null; ) + n = n.slice(0, r.index) + "++" + n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex); + let i; + for (;(r = this.tokenizer.rules.inline.blockSkip.exec(n)) != null; ) + i = r[2] ? r[2].length : 0, n = n.slice(0, r.index + i) + "[" + "a".repeat(r[0].length - i - 2) + "]" + n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex); + n = this.options.hooks?.emStrongMask?.call({ lexer: this }, n) ?? n; + let s = false, a = ""; + for (;e; ) { + s || (a = ""), s = false; + let o; + if (this.options.extensions?.inline?.some((p) => (o = p.call({ lexer: this }, e, t)) ? (e = e.substring(o.raw.length), t.push(o), true) : false)) + continue; + if (o = this.tokenizer.escape(e)) { + e = e.substring(o.raw.length), t.push(o); + continue; + } + if (o = this.tokenizer.tag(e)) { + e = e.substring(o.raw.length), t.push(o); + continue; + } + if (o = this.tokenizer.link(e)) { + e = e.substring(o.raw.length), t.push(o); + continue; + } + if (o = this.tokenizer.reflink(e, this.tokens.links)) { + e = e.substring(o.raw.length); + let p = t.at(-1); + o.type === "text" && p?.type === "text" ? (p.raw += o.raw, p.text += o.text) : t.push(o); + continue; + } + if (o = this.tokenizer.emStrong(e, n, a)) { + e = e.substring(o.raw.length), t.push(o); + continue; + } + if (o = this.tokenizer.codespan(e)) { + e = e.substring(o.raw.length), t.push(o); + continue; + } + if (o = this.tokenizer.br(e)) { + e = e.substring(o.raw.length), t.push(o); + continue; + } + if (o = this.tokenizer.del(e, n, a)) { + e = e.substring(o.raw.length), t.push(o); + continue; + } + if (o = this.tokenizer.autolink(e)) { + e = e.substring(o.raw.length), t.push(o); + continue; + } + if (!this.state.inLink && (o = this.tokenizer.url(e))) { + e = e.substring(o.raw.length), t.push(o); + continue; + } + let l = e; + if (this.options.extensions?.startInline) { + let p = 1 / 0, c = e.slice(1), d; + this.options.extensions.startInline.forEach((h) => { + d = h.call({ lexer: this }, c), typeof d == "number" && d >= 0 && (p = Math.min(p, d)); + }), p < 1 / 0 && p >= 0 && (l = e.substring(0, p + 1)); + } + if (o = this.tokenizer.inlineText(l)) { + e = e.substring(o.raw.length), o.raw.slice(-1) !== "_" && (a = o.raw.slice(-1)), s = true; + let p = t.at(-1); + p?.type === "text" ? (p.raw += o.raw, p.text += o.text) : t.push(o); + continue; + } + if (e) { + let p = "Infinite loop on byte: " + e.charCodeAt(0); + if (this.options.silent) { + console.error(p); + break; + } else + throw new Error(p); + } + } + return t; + } + }; + var y = class { + options; + parser; + constructor(e) { + this.options = e || T; + } + space(e) { + return ""; + } + code({ text: e, lang: t, escaped: n }) { + let r = (t || "").match(m.notSpaceStart)?.[0], i = e.replace(m.endingNewline, "") + ` +`; + return r ? '
' + (n ? i : O(i, true)) + `
+` : "
" + (n ? i : O(i, true)) + `
+`; + } + blockquote({ tokens: e }) { + return `
+${this.parser.parse(e)}
+`; + } + html({ text: e }) { + return e; + } + def(e) { + return ""; + } + heading({ tokens: e, depth: t }) { + return `${this.parser.parseInline(e)} +`; + } + hr(e) { + return `
+`; + } + list(e) { + let { ordered: t, start: n } = e, r = ""; + for (let a = 0;a < e.items.length; a++) { + let o = e.items[a]; + r += this.listitem(o); + } + let i = t ? "ol" : "ul", s = t && n !== 1 ? ' start="' + n + '"' : ""; + return "<" + i + s + `> +` + r + " +`; + } + listitem(e) { + return `
  • ${this.parser.parse(e.tokens)}
    • +`; + } + checkbox({ checked: e }) { + return " '; + } + paragraph({ tokens: e }) { + return `

    ${this.parser.parseInline(e)}

    +`; + } + table(e) { + let t = "", n = ""; + for (let i = 0;i < e.header.length; i++) + n += this.tablecell(e.header[i]); + t += this.tablerow({ text: n }); + let r = ""; + for (let i = 0;i < e.rows.length; i++) { + let s = e.rows[i]; + n = ""; + for (let a = 0;a < s.length; a++) + n += this.tablecell(s[a]); + r += this.tablerow({ text: n }); + } + return r && (r = `${r}`), ` + +` + t + ` +` + r + `
    +`; + } + tablerow({ text: e }) { + return ` +${e} +`; + } + tablecell(e) { + let t = this.parser.parseInline(e.tokens), n = e.header ? "th" : "td"; + return (e.align ? `<${n} align="${e.align}">` : `<${n}>`) + t + ` +`; + } + strong({ tokens: e }) { + return `${this.parser.parseInline(e)}`; + } + em({ tokens: e }) { + return `${this.parser.parseInline(e)}`; + } + codespan({ text: e }) { + return `${O(e, true)}`; + } + br(e) { + return "
    "; + } + del({ tokens: e }) { + return `${this.parser.parseInline(e)}`; + } + link({ href: e, title: t, tokens: n }) { + let r = this.parser.parseInline(n), i = X(e); + if (i === null) + return r; + e = i; + let s = '    ", s; + } + image({ href: e, title: t, text: n, tokens: r }) { + r && (n = this.parser.parseInline(r, this.parser.textRenderer)); + let i = X(e); + if (i === null) + return O(n); + e = i; + let s = `${O(n)} { + let a = i[s].flat(1 / 0); + n = n.concat(this.walkTokens(a, t)); + }) : i.tokens && (n = n.concat(this.walkTokens(i.tokens, t))); + } + } + return n; + } + use(...e) { + let t = this.defaults.extensions || { renderers: {}, childTokens: {} }; + return e.forEach((n) => { + let r = { ...n }; + if (r.async = this.defaults.async || r.async || false, n.extensions && (n.extensions.forEach((i) => { + if (!i.name) + throw new Error("extension name required"); + if ("renderer" in i) { + let s = t.renderers[i.name]; + s ? t.renderers[i.name] = function(...a) { + let o = i.renderer.apply(this, a); + return o === false && (o = s.apply(this, a)), o; + } : t.renderers[i.name] = i.renderer; + } + if ("tokenizer" in i) { + if (!i.level || i.level !== "block" && i.level !== "inline") + throw new Error("extension level must be 'block' or 'inline'"); + let s = t[i.level]; + s ? s.unshift(i.tokenizer) : t[i.level] = [i.tokenizer], i.start && (i.level === "block" ? t.startBlock ? t.startBlock.push(i.start) : t.startBlock = [i.start] : i.level === "inline" && (t.startInline ? t.startInline.push(i.start) : t.startInline = [i.start])); + } + "childTokens" in i && i.childTokens && (t.childTokens[i.name] = i.childTokens); + }), r.extensions = t), n.renderer) { + let i = this.defaults.renderer || new y(this.defaults); + for (let s in n.renderer) { + if (!(s in i)) + throw new Error(`renderer '${s}' does not exist`); + if (["options", "parser"].includes(s)) + continue; + let a = s, o = n.renderer[a], l = i[a]; + i[a] = (...p) => { + let c = o.apply(i, p); + return c === false && (c = l.apply(i, p)), c || ""; + }; + } + r.renderer = i; + } + if (n.tokenizer) { + let i = this.defaults.tokenizer || new w(this.defaults); + for (let s in n.tokenizer) { + if (!(s in i)) + throw new Error(`tokenizer '${s}' does not exist`); + if (["options", "rules", "lexer"].includes(s)) + continue; + let a = s, o = n.tokenizer[a], l = i[a]; + i[a] = (...p) => { + let c = o.apply(i, p); + return c === false && (c = l.apply(i, p)), c; + }; + } + r.tokenizer = i; + } + if (n.hooks) { + let i = this.defaults.hooks || new P; + for (let s in n.hooks) { + if (!(s in i)) + throw new Error(`hook '${s}' does not exist`); + if (["options", "block"].includes(s)) + continue; + let a = s, o = n.hooks[a], l = i[a]; + P.passThroughHooks.has(s) ? i[a] = (p) => { + if (this.defaults.async && P.passThroughHooksRespectAsync.has(s)) + return (async () => { + let d = await o.call(i, p); + return l.call(i, d); + })(); + let c = o.call(i, p); + return l.call(i, c); + } : i[a] = (...p) => { + if (this.defaults.async) + return (async () => { + let d = await o.apply(i, p); + return d === false && (d = await l.apply(i, p)), d; + })(); + let c = o.apply(i, p); + return c === false && (c = l.apply(i, p)), c; + }; + } + r.hooks = i; + } + if (n.walkTokens) { + let i = this.defaults.walkTokens, s = n.walkTokens; + r.walkTokens = function(a) { + let o = []; + return o.push(s.call(this, a)), i && (o = o.concat(i.call(this, a))), o; + }; + } + this.defaults = { ...this.defaults, ...r }; + }), this; + } + setOptions(e) { + return this.defaults = { ...this.defaults, ...e }, this; + } + lexer(e, t) { + return x.lex(e, t ?? this.defaults); + } + parser(e, t) { + return b.parse(e, t ?? this.defaults); + } + parseMarkdown(e) { + return (n, r) => { + let i = { ...r }, s = { ...this.defaults, ...i }, a = this.onError(!!s.silent, !!s.async); + if (this.defaults.async === true && i.async === false) + return a(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise.")); + if (typeof n > "u" || n === null) + return a(new Error("marked(): input parameter is undefined or null")); + if (typeof n != "string") + return a(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(n) + ", string expected")); + if (s.hooks && (s.hooks.options = s, s.hooks.block = e), s.async) + return (async () => { + let o = s.hooks ? await s.hooks.preprocess(n) : n, p = await (s.hooks ? await s.hooks.provideLexer() : e ? x.lex : x.lexInline)(o, s), c = s.hooks ? await s.hooks.processAllTokens(p) : p; + s.walkTokens && await Promise.all(this.walkTokens(c, s.walkTokens)); + let h = await (s.hooks ? await s.hooks.provideParser() : e ? b.parse : b.parseInline)(c, s); + return s.hooks ? await s.hooks.postprocess(h) : h; + })().catch(a); + try { + s.hooks && (n = s.hooks.preprocess(n)); + let l = (s.hooks ? s.hooks.provideLexer() : e ? x.lex : x.lexInline)(n, s); + s.hooks && (l = s.hooks.processAllTokens(l)), s.walkTokens && this.walkTokens(l, s.walkTokens); + let c = (s.hooks ? s.hooks.provideParser() : e ? b.parse : b.parseInline)(l, s); + return s.hooks && (c = s.hooks.postprocess(c)), c; + } catch (o) { + return a(o); + } + }; + } + onError(e, t) { + return (n) => { + if (n.message += ` +Please report this to https://github.com/markedjs/marked.`, e) { + let r = "

    An error occurred:

    " + O(n.message + "", true) + "
    "; + return t ? Promise.resolve(r) : r; + } + if (t) + return Promise.reject(n); + throw n; + }; + } + }; + var L = new B; + function g(u3, e) { + return L.parse(u3, e); + } + g.options = g.setOptions = function(u3) { + return L.setOptions(u3), g.defaults = L.defaults, G(g.defaults), g; + }; + g.getDefaults = M; + g.defaults = T; + g.use = function(...u3) { + return L.use(...u3), g.defaults = L.defaults, G(g.defaults), g; + }; + g.walkTokens = function(u3, e) { + return L.walkTokens(u3, e); + }; + g.parseInline = L.parseInline; + g.Parser = b; + g.parser = b.parse; + g.Renderer = y; + g.TextRenderer = $; + g.Lexer = x; + g.lexer = x.lex; + g.Tokenizer = w; + g.Hooks = P; + g.parse = g; + var Ut = g.options; + var Kt = g.setOptions; + var Wt = g.use; + var Xt = g.walkTokens; + var Jt = g.parseInline; + var Yt = b.parse; + var en = x.lex; + + // node_modules/highlight.js/es/core.js + var import_core = __toESM(require_core(), 1); + var core_default = import_core.default; + + // node_modules/highlight.js/es/languages/javascript.js + var IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*"; + var KEYWORDS = [ + "as", + "in", + "of", + "if", + "for", + "while", + "finally", + "var", + "new", + "function", + "do", + "return", + "void", + "else", + "break", + "catch", + "instanceof", + "with", + "throw", + "case", + "default", + "try", + "switch", + "continue", + "typeof", + "delete", + "let", + "yield", + "const", + "class", + "debugger", + "async", + "await", + "static", + "import", + "from", + "export", + "extends", + "using" + ]; + var LITERALS = [ + "true", + "false", + "null", + "undefined", + "NaN", + "Infinity" + ]; + var TYPES = [ + "Object", + "Function", + "Boolean", + "Symbol", + "Math", + "Date", + "Number", + "BigInt", + "String", + "RegExp", + "Array", + "Float32Array", + "Float64Array", + "Int8Array", + "Uint8Array", + "Uint8ClampedArray", + "Int16Array", + "Int32Array", + "Uint16Array", + "Uint32Array", + "BigInt64Array", + "BigUint64Array", + "Set", + "Map", + "WeakSet", + "WeakMap", + "ArrayBuffer", + "SharedArrayBuffer", + "Atomics", + "DataView", + "JSON", + "Promise", + "Generator", + "GeneratorFunction", + "AsyncFunction", + "Reflect", + "Proxy", + "Intl", + "WebAssembly" + ]; + var ERROR_TYPES = [ + "Error", + "EvalError", + "InternalError", + "RangeError", + "ReferenceError", + "SyntaxError", + "TypeError", + "URIError" + ]; + var BUILT_IN_GLOBALS = [ + "setInterval", + "setTimeout", + "clearInterval", + "clearTimeout", + "require", + "exports", + "eval", + "isFinite", + "isNaN", + "parseFloat", + "parseInt", + "decodeURI", + "decodeURIComponent", + "encodeURI", + "encodeURIComponent", + "escape", + "unescape" + ]; + var BUILT_IN_VARIABLES = [ + "arguments", + "this", + "super", + "console", + "window", + "document", + "localStorage", + "sessionStorage", + "module", + "global" + ]; + var BUILT_INS = [].concat(BUILT_IN_GLOBALS, TYPES, ERROR_TYPES); + function javascript(hljs) { + const regex = hljs.regex; + const hasClosingTag = (match, { after }) => { + const tag = "", + end: "" + }; + const XML_SELF_CLOSING = /<[A-Za-z0-9\\._:-]+\s*\/>/; + const XML_TAG = { + begin: /<[A-Za-z0-9\\._:-]+/, + end: /\/[A-Za-z0-9\\._:-]+>|\/>/, + isTrulyOpeningTag: (match, response) => { + const afterMatchIndex = match[0].length + match.index; + const nextChar = match.input[afterMatchIndex]; + if (nextChar === "<" || nextChar === ",") { + response.ignoreMatch(); + return; + } + if (nextChar === ">") { + if (!hasClosingTag(match, { after: afterMatchIndex })) { + response.ignoreMatch(); + } + } + let m2; + const afterMatch = match.input.substring(afterMatchIndex); + if (m2 = afterMatch.match(/^\s*=/)) { + response.ignoreMatch(); + return; + } + if (m2 = afterMatch.match(/^\s+extends\s+/)) { + if (m2.index === 0) { + response.ignoreMatch(); + return; + } + } + } + }; + const KEYWORDS$1 = { + $pattern: IDENT_RE, + keyword: KEYWORDS, + literal: LITERALS, + built_in: BUILT_INS, + "variable.language": BUILT_IN_VARIABLES + }; + const decimalDigits = "[0-9](_?[0-9])*"; + const frac = `\\.(${decimalDigits})`; + const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`; + const NUMBER = { + className: "number", + variants: [ + { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))` + `[eE][+-]?(${decimalDigits})\\b` }, + { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` }, + { begin: `\\b(0|[1-9](_?[0-9])*)n\\b` }, + { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" }, + { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" }, + { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" }, + { begin: "\\b0[0-7]+n?\\b" } + ], + relevance: 0 + }; + const SUBST = { + className: "subst", + begin: "\\$\\{", + end: "\\}", + keywords: KEYWORDS$1, + contains: [] + }; + const HTML_TEMPLATE = { + begin: ".?html`", + end: "", + starts: { + end: "`", + returnEnd: false, + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ], + subLanguage: "xml" + } + }; + const CSS_TEMPLATE = { + begin: ".?css`", + end: "", + starts: { + end: "`", + returnEnd: false, + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ], + subLanguage: "css" + } + }; + const GRAPHQL_TEMPLATE = { + begin: ".?gql`", + end: "", + starts: { + end: "`", + returnEnd: false, + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ], + subLanguage: "graphql" + } + }; + const TEMPLATE_STRING = { + className: "string", + begin: "`", + end: "`", + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ] + }; + const JSDOC_COMMENT = hljs.COMMENT(/\/\*\*(?!\/)/, "\\*/", { + relevance: 0, + contains: [ + { + begin: "(?=@[A-Za-z]+)", + relevance: 0, + contains: [ + { + className: "doctag", + begin: "@[A-Za-z]+" + }, + { + className: "type", + begin: "\\{", + end: "\\}", + excludeEnd: true, + excludeBegin: true, + relevance: 0 + }, + { + className: "variable", + begin: IDENT_RE$1 + "(?=\\s*(-)|$)", + endsParent: true, + relevance: 0 + }, + { + begin: /(?=[^\n])\s/, + relevance: 0 + } + ] + } + ] + }); + const COMMENT = { + className: "comment", + variants: [ + JSDOC_COMMENT, + hljs.C_BLOCK_COMMENT_MODE, + hljs.C_LINE_COMMENT_MODE + ] + }; + const SUBST_INTERNALS = [ + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE, + HTML_TEMPLATE, + CSS_TEMPLATE, + GRAPHQL_TEMPLATE, + TEMPLATE_STRING, + { match: /\$\d+/ }, + NUMBER + ]; + SUBST.contains = SUBST_INTERNALS.concat({ + begin: /\{/, + end: /\}/, + keywords: KEYWORDS$1, + contains: [ + "self" + ].concat(SUBST_INTERNALS) + }); + const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains); + const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([ + { + begin: /(\s*)\(/, + end: /\)/, + keywords: KEYWORDS$1, + contains: ["self"].concat(SUBST_AND_COMMENTS) + } + ]); + const PARAMS = { + className: "params", + begin: /(\s*)\(/, + end: /\)/, + excludeBegin: true, + excludeEnd: true, + keywords: KEYWORDS$1, + contains: PARAMS_CONTAINS + }; + const CLASS_OR_EXTENDS = { + variants: [ + { + match: [ + /class/, + /\s+/, + IDENT_RE$1, + /\s+/, + /extends/, + /\s+/, + regex.concat(IDENT_RE$1, "(", regex.concat(/\./, IDENT_RE$1), ")*") + ], + scope: { + 1: "keyword", + 3: "title.class", + 5: "keyword", + 7: "title.class.inherited" + } + }, + { + match: [ + /class/, + /\s+/, + IDENT_RE$1 + ], + scope: { + 1: "keyword", + 3: "title.class" + } + } + ] + }; + const CLASS_REFERENCE = { + relevance: 0, + match: regex.either(/\bJSON/, /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/, /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/, /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/), + className: "title.class", + keywords: { + _: [ + ...TYPES, + ...ERROR_TYPES + ] + } + }; + const USE_STRICT = { + label: "use_strict", + className: "meta", + relevance: 10, + begin: /^\s*['"]use (strict|asm)['"]/ + }; + const FUNCTION_DEFINITION = { + variants: [ + { + match: [ + /function/, + /\s+/, + IDENT_RE$1, + /(?=\s*\()/ + ] + }, + { + match: [ + /function/, + /\s*(?=\()/ + ] + } + ], + className: { + 1: "keyword", + 3: "title.function" + }, + label: "func.def", + contains: [PARAMS], + illegal: /%/ + }; + const UPPER_CASE_CONSTANT = { + relevance: 0, + match: /\b[A-Z][A-Z_0-9]+\b/, + className: "variable.constant" + }; + function noneOf(list) { + return regex.concat("(?!", list.join("|"), ")"); + } + const FUNCTION_CALL = { + match: regex.concat(/\b/, noneOf([ + ...BUILT_IN_GLOBALS, + "super", + "import" + ].map((x2) => `${x2}\\s*\\(`)), IDENT_RE$1, regex.lookahead(/\s*\(/)), + className: "title.function", + relevance: 0 + }; + const PROPERTY_ACCESS = { + begin: regex.concat(/\./, regex.lookahead(regex.concat(IDENT_RE$1, /(?![0-9A-Za-z$_(])/))), + end: IDENT_RE$1, + excludeBegin: true, + keywords: "prototype", + className: "property", + relevance: 0 + }; + const GETTER_OR_SETTER = { + match: [ + /get|set/, + /\s+/, + IDENT_RE$1, + /(?=\()/ + ], + className: { + 1: "keyword", + 3: "title.function" + }, + contains: [ + { + begin: /\(\)/ + }, + PARAMS + ] + }; + const FUNC_LEAD_IN_RE = "(\\(" + "[^()]*(\\(" + "[^()]*(\\(" + "[^()]*" + "\\)[^()]*)*" + "\\)[^()]*)*" + "\\)|" + hljs.UNDERSCORE_IDENT_RE + ")\\s*=>"; + const FUNCTION_VARIABLE = { + match: [ + /const|var|let/, + /\s+/, + IDENT_RE$1, + /\s*/, + /=\s*/, + /(async\s*)?/, + regex.lookahead(FUNC_LEAD_IN_RE) + ], + keywords: "async", + className: { + 1: "keyword", + 3: "title.function" + }, + contains: [ + PARAMS + ] + }; + return { + name: "JavaScript", + aliases: ["js", "jsx", "mjs", "cjs"], + keywords: KEYWORDS$1, + exports: { PARAMS_CONTAINS, CLASS_REFERENCE }, + illegal: /#(?![$_A-z])/, + contains: [ + hljs.SHEBANG({ + label: "shebang", + binary: "node", + relevance: 5 + }), + USE_STRICT, + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE, + HTML_TEMPLATE, + CSS_TEMPLATE, + GRAPHQL_TEMPLATE, + TEMPLATE_STRING, + COMMENT, + { match: /\$\d+/ }, + NUMBER, + CLASS_REFERENCE, + { + scope: "attr", + match: IDENT_RE$1 + regex.lookahead(":"), + relevance: 0 + }, + FUNCTION_VARIABLE, + { + begin: "(" + hljs.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*", + keywords: "return throw case", + relevance: 0, + contains: [ + COMMENT, + hljs.REGEXP_MODE, + { + className: "function", + begin: FUNC_LEAD_IN_RE, + returnBegin: true, + end: "\\s*=>", + contains: [ + { + className: "params", + variants: [ + { + begin: hljs.UNDERSCORE_IDENT_RE, + relevance: 0 + }, + { + className: null, + begin: /\(\s*\)/, + skip: true + }, + { + begin: /(\s*)\(/, + end: /\)/, + excludeBegin: true, + excludeEnd: true, + keywords: KEYWORDS$1, + contains: PARAMS_CONTAINS + } + ] + } + ] + }, + { + begin: /,/, + relevance: 0 + }, + { + match: /\s+/, + relevance: 0 + }, + { + variants: [ + { begin: FRAGMENT.begin, end: FRAGMENT.end }, + { match: XML_SELF_CLOSING }, + { + begin: XML_TAG.begin, + "on:begin": XML_TAG.isTrulyOpeningTag, + end: XML_TAG.end + } + ], + subLanguage: "xml", + contains: [ + { + begin: XML_TAG.begin, + end: XML_TAG.end, + skip: true, + contains: ["self"] + } + ] + } + ] + }, + FUNCTION_DEFINITION, + { + beginKeywords: "while if switch catch for" + }, + { + begin: "\\b(?!function)" + hljs.UNDERSCORE_IDENT_RE + "\\(" + "[^()]*(\\(" + "[^()]*(\\(" + "[^()]*" + "\\)[^()]*)*" + "\\)[^()]*)*" + "\\)\\s*\\{", + returnBegin: true, + label: "func.def", + contains: [ + PARAMS, + hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1, className: "title.function" }) + ] + }, + { + match: /\.\.\./, + relevance: 0 + }, + PROPERTY_ACCESS, + { + match: "\\$" + IDENT_RE$1, + relevance: 0 + }, + { + match: [/\bconstructor(?=\s*\()/], + className: { 1: "title.function" }, + contains: [PARAMS] + }, + FUNCTION_CALL, + UPPER_CASE_CONSTANT, + CLASS_OR_EXTENDS, + GETTER_OR_SETTER, + { + match: /\$[(.]/ + } + ] + }; + } + + // node_modules/highlight.js/es/languages/python.js + function python(hljs) { + const regex = hljs.regex; + const IDENT_RE2 = /[\p{XID_Start}_]\p{XID_Continue}*/u; + const RESERVED_WORDS = [ + "and", + "as", + "assert", + "async", + "await", + "break", + "case", + "class", + "continue", + "def", + "del", + "elif", + "else", + "except", + "finally", + "for", + "from", + "global", + "if", + "import", + "in", + "is", + "lambda", + "match", + "nonlocal|10", + "not", + "or", + "pass", + "raise", + "return", + "try", + "while", + "with", + "yield" + ]; + const BUILT_INS2 = [ + "__import__", + "abs", + "all", + "any", + "ascii", + "bin", + "bool", + "breakpoint", + "bytearray", + "bytes", + "callable", + "chr", + "classmethod", + "compile", + "complex", + "delattr", + "dict", + "dir", + "divmod", + "enumerate", + "eval", + "exec", + "filter", + "float", + "format", + "frozenset", + "getattr", + "globals", + "hasattr", + "hash", + "help", + "hex", + "id", + "input", + "int", + "isinstance", + "issubclass", + "iter", + "len", + "list", + "locals", + "map", + "max", + "memoryview", + "min", + "next", + "object", + "oct", + "open", + "ord", + "pow", + "print", + "property", + "range", + "repr", + "reversed", + "round", + "set", + "setattr", + "slice", + "sorted", + "staticmethod", + "str", + "sum", + "super", + "tuple", + "type", + "vars", + "zip" + ]; + const LITERALS2 = [ + "__debug__", + "Ellipsis", + "False", + "None", + "NotImplemented", + "True" + ]; + const TYPES2 = [ + "Any", + "Callable", + "Coroutine", + "Dict", + "List", + "Literal", + "Generic", + "Optional", + "Sequence", + "Set", + "Tuple", + "Type", + "Union" + ]; + const KEYWORDS2 = { + $pattern: /[A-Za-z]\w+|__\w+__/, + keyword: RESERVED_WORDS, + built_in: BUILT_INS2, + literal: LITERALS2, + type: TYPES2 + }; + const PROMPT = { + className: "meta", + begin: /^(>>>|\.\.\.) / + }; + const SUBST = { + className: "subst", + begin: /\{/, + end: /\}/, + keywords: KEYWORDS2, + illegal: /#/ + }; + const LITERAL_BRACKET = { + begin: /\{\{/, + relevance: 0 + }; + const STRING = { + className: "string", + contains: [hljs.BACKSLASH_ESCAPE], + variants: [ + { + begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/, + end: /'''/, + contains: [ + hljs.BACKSLASH_ESCAPE, + PROMPT + ], + relevance: 10 + }, + { + begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/, + end: /"""/, + contains: [ + hljs.BACKSLASH_ESCAPE, + PROMPT + ], + relevance: 10 + }, + { + begin: /([fF][rR]|[rR][fF]|[fF])'''/, + end: /'''/, + contains: [ + hljs.BACKSLASH_ESCAPE, + PROMPT, + LITERAL_BRACKET, + SUBST + ] + }, + { + begin: /([fF][rR]|[rR][fF]|[fF])"""/, + end: /"""/, + contains: [ + hljs.BACKSLASH_ESCAPE, + PROMPT, + LITERAL_BRACKET, + SUBST + ] + }, + { + begin: /([uU]|[rR])'/, + end: /'/, + relevance: 10 + }, + { + begin: /([uU]|[rR])"/, + end: /"/, + relevance: 10 + }, + { + begin: /([bB]|[bB][rR]|[rR][bB])'/, + end: /'/ + }, + { + begin: /([bB]|[bB][rR]|[rR][bB])"/, + end: /"/ + }, + { + begin: /([fF][rR]|[rR][fF]|[fF])'/, + end: /'/, + contains: [ + hljs.BACKSLASH_ESCAPE, + LITERAL_BRACKET, + SUBST + ] + }, + { + begin: /([fF][rR]|[rR][fF]|[fF])"/, + end: /"/, + contains: [ + hljs.BACKSLASH_ESCAPE, + LITERAL_BRACKET, + SUBST + ] + }, + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE + ] + }; + const digitpart = "[0-9](_?[0-9])*"; + const pointfloat = `(\\b(${digitpart}))?\\.(${digitpart})|\\b(${digitpart})\\.`; + const lookahead = `\\b|${RESERVED_WORDS.join("|")}`; + const NUMBER = { + className: "number", + relevance: 0, + variants: [ + { + begin: `(\\b(${digitpart})|(${pointfloat}))[eE][+-]?(${digitpart})[jJ]?(?=${lookahead})` + }, + { + begin: `(${pointfloat})[jJ]?` + }, + { + begin: `\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${lookahead})` + }, + { + begin: `\\b0[bB](_?[01])+[lL]?(?=${lookahead})` + }, + { + begin: `\\b0[oO](_?[0-7])+[lL]?(?=${lookahead})` + }, + { + begin: `\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${lookahead})` + }, + { + begin: `\\b(${digitpart})[jJ](?=${lookahead})` + } + ] + }; + const COMMENT_TYPE = { + className: "comment", + begin: regex.lookahead(/# type:/), + end: /$/, + keywords: KEYWORDS2, + contains: [ + { + begin: /# type:/ + }, + { + begin: /#/, + end: /\b\B/, + endsWithParent: true + } + ] + }; + const PARAMS = { + className: "params", + variants: [ + { + className: "", + begin: /\(\s*\)/, + skip: true + }, + { + begin: /\(/, + end: /\)/, + excludeBegin: true, + excludeEnd: true, + keywords: KEYWORDS2, + contains: [ + "self", + PROMPT, + NUMBER, + STRING, + hljs.HASH_COMMENT_MODE + ] + } + ] + }; + SUBST.contains = [ + STRING, + NUMBER, + PROMPT + ]; + return { + name: "Python", + aliases: [ + "py", + "gyp", + "ipython" + ], + unicodeRegex: true, + keywords: KEYWORDS2, + illegal: /(<\/|\?)|=>/, + contains: [ + PROMPT, + NUMBER, + { + scope: "variable.language", + match: /\bself\b/ + }, + { + beginKeywords: "if", + relevance: 0 + }, + { match: /\bor\b/, scope: "keyword" }, + STRING, + COMMENT_TYPE, + hljs.HASH_COMMENT_MODE, + { + match: [ + /\bdef/, + /\s+/, + IDENT_RE2 + ], + scope: { + 1: "keyword", + 3: "title.function" + }, + contains: [PARAMS] + }, + { + variants: [ + { + match: [ + /\bclass/, + /\s+/, + IDENT_RE2, + /\s*/, + /\(\s*/, + IDENT_RE2, + /\s*\)/ + ] + }, + { + match: [ + /\bclass/, + /\s+/, + IDENT_RE2 + ] + } + ], + scope: { + 1: "keyword", + 3: "title.class", + 6: "title.class.inherited" + } + }, + { + className: "meta", + begin: /^[\t ]*@/, + end: /(?=#)|$/, + contains: [ + NUMBER, + PARAMS, + STRING + ] + } + ] + }; + } + + // node_modules/highlight.js/es/languages/go.js + function go(hljs) { + const LITERALS2 = [ + "true", + "false", + "iota", + "nil" + ]; + const BUILT_INS2 = [ + "append", + "cap", + "close", + "complex", + "copy", + "imag", + "len", + "make", + "new", + "panic", + "print", + "println", + "real", + "recover", + "delete" + ]; + const TYPES2 = [ + "bool", + "byte", + "complex64", + "complex128", + "error", + "float32", + "float64", + "int8", + "int16", + "int32", + "int64", + "string", + "uint8", + "uint16", + "uint32", + "uint64", + "int", + "uint", + "uintptr", + "rune" + ]; + const KWS = [ + "break", + "case", + "chan", + "const", + "continue", + "default", + "defer", + "else", + "fallthrough", + "for", + "func", + "go", + "goto", + "if", + "import", + "interface", + "map", + "package", + "range", + "return", + "select", + "struct", + "switch", + "type", + "var" + ]; + const KEYWORDS2 = { + keyword: KWS, + type: TYPES2, + literal: LITERALS2, + built_in: BUILT_INS2 + }; + return { + name: "Go", + aliases: ["golang"], + keywords: KEYWORDS2, + illegal: "]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*" + }, + { + begin: "<%[%=-]?", + end: "[%-]?%>", + subLanguage: "ruby", + excludeBegin: true, + excludeEnd: true, + relevance: 0 + }, + { + className: "type", + begin: "!\\w+!" + URI_CHARACTERS + }, + { + className: "type", + begin: "!<" + URI_CHARACTERS + ">" + }, + { + className: "type", + begin: "!" + URI_CHARACTERS + }, + { + className: "type", + begin: "!!" + URI_CHARACTERS + }, + { + className: "meta", + begin: "&" + hljs.UNDERSCORE_IDENT_RE + "$" + }, + { + className: "meta", + begin: "\\*" + hljs.UNDERSCORE_IDENT_RE + "$" + }, + { + className: "bullet", + begin: "-(?=[ ]|$)", + relevance: 0 + }, + hljs.HASH_COMMENT_MODE, + { + beginKeywords: LITERALS2, + keywords: { literal: LITERALS2 } + }, + TIMESTAMP, + { + className: "number", + begin: hljs.C_NUMBER_RE + "\\b", + relevance: 0 + }, + OBJECT, + ARRAY, + SINGLE_QUOTE_STRING, + STRING + ]; + const VALUE_MODES = [...MODES]; + VALUE_MODES.pop(); + VALUE_MODES.push(CONTAINER_STRING); + VALUE_CONTAINER.contains = VALUE_MODES; + return { + name: "YAML", + case_insensitive: true, + aliases: ["yml"], + contains: MODES + }; + } + + // node_modules/highlight.js/es/languages/typescript.js + var IDENT_RE2 = "[A-Za-z$_][0-9A-Za-z$_]*"; + var KEYWORDS2 = [ + "as", + "in", + "of", + "if", + "for", + "while", + "finally", + "var", + "new", + "function", + "do", + "return", + "void", + "else", + "break", + "catch", + "instanceof", + "with", + "throw", + "case", + "default", + "try", + "switch", + "continue", + "typeof", + "delete", + "let", + "yield", + "const", + "class", + "debugger", + "async", + "await", + "static", + "import", + "from", + "export", + "extends", + "using" + ]; + var LITERALS2 = [ + "true", + "false", + "null", + "undefined", + "NaN", + "Infinity" + ]; + var TYPES2 = [ + "Object", + "Function", + "Boolean", + "Symbol", + "Math", + "Date", + "Number", + "BigInt", + "String", + "RegExp", + "Array", + "Float32Array", + "Float64Array", + "Int8Array", + "Uint8Array", + "Uint8ClampedArray", + "Int16Array", + "Int32Array", + "Uint16Array", + "Uint32Array", + "BigInt64Array", + "BigUint64Array", + "Set", + "Map", + "WeakSet", + "WeakMap", + "ArrayBuffer", + "SharedArrayBuffer", + "Atomics", + "DataView", + "JSON", + "Promise", + "Generator", + "GeneratorFunction", + "AsyncFunction", + "Reflect", + "Proxy", + "Intl", + "WebAssembly" + ]; + var ERROR_TYPES2 = [ + "Error", + "EvalError", + "InternalError", + "RangeError", + "ReferenceError", + "SyntaxError", + "TypeError", + "URIError" + ]; + var BUILT_IN_GLOBALS2 = [ + "setInterval", + "setTimeout", + "clearInterval", + "clearTimeout", + "require", + "exports", + "eval", + "isFinite", + "isNaN", + "parseFloat", + "parseInt", + "decodeURI", + "decodeURIComponent", + "encodeURI", + "encodeURIComponent", + "escape", + "unescape" + ]; + var BUILT_IN_VARIABLES2 = [ + "arguments", + "this", + "super", + "console", + "window", + "document", + "localStorage", + "sessionStorage", + "module", + "global" + ]; + var BUILT_INS2 = [].concat(BUILT_IN_GLOBALS2, TYPES2, ERROR_TYPES2); + function javascript2(hljs) { + const regex = hljs.regex; + const hasClosingTag = (match, { after }) => { + const tag = "", + end: "" + }; + const XML_SELF_CLOSING = /<[A-Za-z0-9\\._:-]+\s*\/>/; + const XML_TAG = { + begin: /<[A-Za-z0-9\\._:-]+/, + end: /\/[A-Za-z0-9\\._:-]+>|\/>/, + isTrulyOpeningTag: (match, response) => { + const afterMatchIndex = match[0].length + match.index; + const nextChar = match.input[afterMatchIndex]; + if (nextChar === "<" || nextChar === ",") { + response.ignoreMatch(); + return; + } + if (nextChar === ">") { + if (!hasClosingTag(match, { after: afterMatchIndex })) { + response.ignoreMatch(); + } + } + let m2; + const afterMatch = match.input.substring(afterMatchIndex); + if (m2 = afterMatch.match(/^\s*=/)) { + response.ignoreMatch(); + return; + } + if (m2 = afterMatch.match(/^\s+extends\s+/)) { + if (m2.index === 0) { + response.ignoreMatch(); + return; + } + } + } + }; + const KEYWORDS$1 = { + $pattern: IDENT_RE2, + keyword: KEYWORDS2, + literal: LITERALS2, + built_in: BUILT_INS2, + "variable.language": BUILT_IN_VARIABLES2 + }; + const decimalDigits = "[0-9](_?[0-9])*"; + const frac = `\\.(${decimalDigits})`; + const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`; + const NUMBER = { + className: "number", + variants: [ + { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))` + `[eE][+-]?(${decimalDigits})\\b` }, + { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` }, + { begin: `\\b(0|[1-9](_?[0-9])*)n\\b` }, + { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" }, + { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" }, + { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" }, + { begin: "\\b0[0-7]+n?\\b" } + ], + relevance: 0 + }; + const SUBST = { + className: "subst", + begin: "\\$\\{", + end: "\\}", + keywords: KEYWORDS$1, + contains: [] + }; + const HTML_TEMPLATE = { + begin: ".?html`", + end: "", + starts: { + end: "`", + returnEnd: false, + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ], + subLanguage: "xml" + } + }; + const CSS_TEMPLATE = { + begin: ".?css`", + end: "", + starts: { + end: "`", + returnEnd: false, + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ], + subLanguage: "css" + } + }; + const GRAPHQL_TEMPLATE = { + begin: ".?gql`", + end: "", + starts: { + end: "`", + returnEnd: false, + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ], + subLanguage: "graphql" + } + }; + const TEMPLATE_STRING = { + className: "string", + begin: "`", + end: "`", + contains: [ + hljs.BACKSLASH_ESCAPE, + SUBST + ] + }; + const JSDOC_COMMENT = hljs.COMMENT(/\/\*\*(?!\/)/, "\\*/", { + relevance: 0, + contains: [ + { + begin: "(?=@[A-Za-z]+)", + relevance: 0, + contains: [ + { + className: "doctag", + begin: "@[A-Za-z]+" + }, + { + className: "type", + begin: "\\{", + end: "\\}", + excludeEnd: true, + excludeBegin: true, + relevance: 0 + }, + { + className: "variable", + begin: IDENT_RE$1 + "(?=\\s*(-)|$)", + endsParent: true, + relevance: 0 + }, + { + begin: /(?=[^\n])\s/, + relevance: 0 + } + ] + } + ] + }); + const COMMENT = { + className: "comment", + variants: [ + JSDOC_COMMENT, + hljs.C_BLOCK_COMMENT_MODE, + hljs.C_LINE_COMMENT_MODE + ] + }; + const SUBST_INTERNALS = [ + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE, + HTML_TEMPLATE, + CSS_TEMPLATE, + GRAPHQL_TEMPLATE, + TEMPLATE_STRING, + { match: /\$\d+/ }, + NUMBER + ]; + SUBST.contains = SUBST_INTERNALS.concat({ + begin: /\{/, + end: /\}/, + keywords: KEYWORDS$1, + contains: [ + "self" + ].concat(SUBST_INTERNALS) + }); + const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains); + const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([ + { + begin: /(\s*)\(/, + end: /\)/, + keywords: KEYWORDS$1, + contains: ["self"].concat(SUBST_AND_COMMENTS) + } + ]); + const PARAMS = { + className: "params", + begin: /(\s*)\(/, + end: /\)/, + excludeBegin: true, + excludeEnd: true, + keywords: KEYWORDS$1, + contains: PARAMS_CONTAINS + }; + const CLASS_OR_EXTENDS = { + variants: [ + { + match: [ + /class/, + /\s+/, + IDENT_RE$1, + /\s+/, + /extends/, + /\s+/, + regex.concat(IDENT_RE$1, "(", regex.concat(/\./, IDENT_RE$1), ")*") + ], + scope: { + 1: "keyword", + 3: "title.class", + 5: "keyword", + 7: "title.class.inherited" + } + }, + { + match: [ + /class/, + /\s+/, + IDENT_RE$1 + ], + scope: { + 1: "keyword", + 3: "title.class" + } + } + ] + }; + const CLASS_REFERENCE = { + relevance: 0, + match: regex.either(/\bJSON/, /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/, /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/, /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/), + className: "title.class", + keywords: { + _: [ + ...TYPES2, + ...ERROR_TYPES2 + ] + } + }; + const USE_STRICT = { + label: "use_strict", + className: "meta", + relevance: 10, + begin: /^\s*['"]use (strict|asm)['"]/ + }; + const FUNCTION_DEFINITION = { + variants: [ + { + match: [ + /function/, + /\s+/, + IDENT_RE$1, + /(?=\s*\()/ + ] + }, + { + match: [ + /function/, + /\s*(?=\()/ + ] + } + ], + className: { + 1: "keyword", + 3: "title.function" + }, + label: "func.def", + contains: [PARAMS], + illegal: /%/ + }; + const UPPER_CASE_CONSTANT = { + relevance: 0, + match: /\b[A-Z][A-Z_0-9]+\b/, + className: "variable.constant" + }; + function noneOf(list) { + return regex.concat("(?!", list.join("|"), ")"); + } + const FUNCTION_CALL = { + match: regex.concat(/\b/, noneOf([ + ...BUILT_IN_GLOBALS2, + "super", + "import" + ].map((x2) => `${x2}\\s*\\(`)), IDENT_RE$1, regex.lookahead(/\s*\(/)), + className: "title.function", + relevance: 0 + }; + const PROPERTY_ACCESS = { + begin: regex.concat(/\./, regex.lookahead(regex.concat(IDENT_RE$1, /(?![0-9A-Za-z$_(])/))), + end: IDENT_RE$1, + excludeBegin: true, + keywords: "prototype", + className: "property", + relevance: 0 + }; + const GETTER_OR_SETTER = { + match: [ + /get|set/, + /\s+/, + IDENT_RE$1, + /(?=\()/ + ], + className: { + 1: "keyword", + 3: "title.function" + }, + contains: [ + { + begin: /\(\)/ + }, + PARAMS + ] + }; + const FUNC_LEAD_IN_RE = "(\\(" + "[^()]*(\\(" + "[^()]*(\\(" + "[^()]*" + "\\)[^()]*)*" + "\\)[^()]*)*" + "\\)|" + hljs.UNDERSCORE_IDENT_RE + ")\\s*=>"; + const FUNCTION_VARIABLE = { + match: [ + /const|var|let/, + /\s+/, + IDENT_RE$1, + /\s*/, + /=\s*/, + /(async\s*)?/, + regex.lookahead(FUNC_LEAD_IN_RE) + ], + keywords: "async", + className: { + 1: "keyword", + 3: "title.function" + }, + contains: [ + PARAMS + ] + }; + return { + name: "JavaScript", + aliases: ["js", "jsx", "mjs", "cjs"], + keywords: KEYWORDS$1, + exports: { PARAMS_CONTAINS, CLASS_REFERENCE }, + illegal: /#(?![$_A-z])/, + contains: [ + hljs.SHEBANG({ + label: "shebang", + binary: "node", + relevance: 5 + }), + USE_STRICT, + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE, + HTML_TEMPLATE, + CSS_TEMPLATE, + GRAPHQL_TEMPLATE, + TEMPLATE_STRING, + COMMENT, + { match: /\$\d+/ }, + NUMBER, + CLASS_REFERENCE, + { + scope: "attr", + match: IDENT_RE$1 + regex.lookahead(":"), + relevance: 0 + }, + FUNCTION_VARIABLE, + { + begin: "(" + hljs.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*", + keywords: "return throw case", + relevance: 0, + contains: [ + COMMENT, + hljs.REGEXP_MODE, + { + className: "function", + begin: FUNC_LEAD_IN_RE, + returnBegin: true, + end: "\\s*=>", + contains: [ + { + className: "params", + variants: [ + { + begin: hljs.UNDERSCORE_IDENT_RE, + relevance: 0 + }, + { + className: null, + begin: /\(\s*\)/, + skip: true + }, + { + begin: /(\s*)\(/, + end: /\)/, + excludeBegin: true, + excludeEnd: true, + keywords: KEYWORDS$1, + contains: PARAMS_CONTAINS + } + ] + } + ] + }, + { + begin: /,/, + relevance: 0 + }, + { + match: /\s+/, + relevance: 0 + }, + { + variants: [ + { begin: FRAGMENT.begin, end: FRAGMENT.end }, + { match: XML_SELF_CLOSING }, + { + begin: XML_TAG.begin, + "on:begin": XML_TAG.isTrulyOpeningTag, + end: XML_TAG.end + } + ], + subLanguage: "xml", + contains: [ + { + begin: XML_TAG.begin, + end: XML_TAG.end, + skip: true, + contains: ["self"] + } + ] + } + ] + }, + FUNCTION_DEFINITION, + { + beginKeywords: "while if switch catch for" + }, + { + begin: "\\b(?!function)" + hljs.UNDERSCORE_IDENT_RE + "\\(" + "[^()]*(\\(" + "[^()]*(\\(" + "[^()]*" + "\\)[^()]*)*" + "\\)[^()]*)*" + "\\)\\s*\\{", + returnBegin: true, + label: "func.def", + contains: [ + PARAMS, + hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1, className: "title.function" }) + ] + }, + { + match: /\.\.\./, + relevance: 0 + }, + PROPERTY_ACCESS, + { + match: "\\$" + IDENT_RE$1, + relevance: 0 + }, + { + match: [/\bconstructor(?=\s*\()/], + className: { 1: "title.function" }, + contains: [PARAMS] + }, + FUNCTION_CALL, + UPPER_CASE_CONSTANT, + CLASS_OR_EXTENDS, + GETTER_OR_SETTER, + { + match: /\$[(.]/ + } + ] + }; + } + function typescript(hljs) { + const regex = hljs.regex; + const tsLanguage = javascript2(hljs); + const IDENT_RE$1 = IDENT_RE2; + const TYPES3 = [ + "any", + "void", + "number", + "boolean", + "string", + "object", + "never", + "symbol", + "bigint", + "unknown" + ]; + const NAMESPACE = { + begin: [ + /namespace/, + /\s+/, + hljs.IDENT_RE + ], + beginScope: { + 1: "keyword", + 3: "title.class" + } + }; + const INTERFACE = { + beginKeywords: "interface", + end: /\{/, + excludeEnd: true, + keywords: { + keyword: "interface extends", + built_in: TYPES3 + }, + contains: [tsLanguage.exports.CLASS_REFERENCE] + }; + const USE_STRICT = { + className: "meta", + relevance: 10, + begin: /^\s*['"]use strict['"]/ + }; + const TS_SPECIFIC_KEYWORDS = [ + "type", + "interface", + "public", + "private", + "protected", + "implements", + "declare", + "abstract", + "readonly", + "enum", + "override", + "satisfies" + ]; + const KEYWORDS$1 = { + $pattern: IDENT_RE2, + keyword: KEYWORDS2.concat(TS_SPECIFIC_KEYWORDS), + literal: LITERALS2, + built_in: BUILT_INS2.concat(TYPES3), + "variable.language": BUILT_IN_VARIABLES2 + }; + const DECORATOR = { + className: "meta", + begin: "@" + IDENT_RE$1 + }; + const swapMode = (mode, label, replacement) => { + const indx = mode.contains.findIndex((m2) => m2.label === label); + if (indx === -1) { + throw new Error("can not find mode to replace"); + } + mode.contains.splice(indx, 1, replacement); + }; + Object.assign(tsLanguage.keywords, KEYWORDS$1); + tsLanguage.exports.PARAMS_CONTAINS.push(DECORATOR); + const ATTRIBUTE_HIGHLIGHT = tsLanguage.contains.find((c) => c.scope === "attr"); + const OPTIONAL_KEY_OR_ARGUMENT = Object.assign({}, ATTRIBUTE_HIGHLIGHT, { match: regex.concat(IDENT_RE$1, regex.lookahead(/\s*\?:/)) }); + tsLanguage.exports.PARAMS_CONTAINS.push([ + tsLanguage.exports.CLASS_REFERENCE, + ATTRIBUTE_HIGHLIGHT, + OPTIONAL_KEY_OR_ARGUMENT + ]); + tsLanguage.contains = tsLanguage.contains.concat([ + DECORATOR, + NAMESPACE, + INTERFACE, + OPTIONAL_KEY_OR_ARGUMENT + ]); + swapMode(tsLanguage, "shebang", hljs.SHEBANG()); + swapMode(tsLanguage, "use_strict", USE_STRICT); + const functionDeclaration = tsLanguage.contains.find((m2) => m2.label === "func.def"); + functionDeclaration.relevance = 0; + Object.assign(tsLanguage, { + name: "TypeScript", + aliases: [ + "ts", + "tsx", + "mts", + "cts" + ] + }); + return tsLanguage; + } + + // node_modules/highlight.js/es/languages/sql.js + function sql(hljs) { + const regex = hljs.regex; + const COMMENT_MODE = hljs.COMMENT("--", "$"); + const STRING = { + scope: "string", + variants: [ + { + begin: /'/, + end: /'/, + contains: [{ match: /''/ }] + } + ] + }; + const QUOTED_IDENTIFIER = { + begin: /"/, + end: /"/, + contains: [{ match: /""/ }] + }; + const LITERALS3 = [ + "true", + "false", + "unknown" + ]; + const MULTI_WORD_TYPES = [ + "double precision", + "large object", + "with timezone", + "without timezone" + ]; + const TYPES3 = [ + "bigint", + "binary", + "blob", + "boolean", + "char", + "character", + "clob", + "date", + "dec", + "decfloat", + "decimal", + "float", + "int", + "integer", + "interval", + "nchar", + "nclob", + "national", + "numeric", + "real", + "row", + "smallint", + "time", + "timestamp", + "varchar", + "varying", + "varbinary" + ]; + const NON_RESERVED_WORDS = [ + "add", + "asc", + "collation", + "desc", + "final", + "first", + "last", + "view" + ]; + const RESERVED_WORDS = [ + "abs", + "acos", + "all", + "allocate", + "alter", + "and", + "any", + "are", + "array", + "array_agg", + "array_max_cardinality", + "as", + "asensitive", + "asin", + "asymmetric", + "at", + "atan", + "atomic", + "authorization", + "avg", + "begin", + "begin_frame", + "begin_partition", + "between", + "bigint", + "binary", + "blob", + "boolean", + "both", + "by", + "call", + "called", + "cardinality", + "cascaded", + "case", + "cast", + "ceil", + "ceiling", + "char", + "char_length", + "character", + "character_length", + "check", + "classifier", + "clob", + "close", + "coalesce", + "collate", + "collect", + "column", + "commit", + "condition", + "connect", + "constraint", + "contains", + "convert", + "copy", + "corr", + "corresponding", + "cos", + "cosh", + "count", + "covar_pop", + "covar_samp", + "create", + "cross", + "cube", + "cume_dist", + "current", + "current_catalog", + "current_date", + "current_default_transform_group", + "current_path", + "current_role", + "current_row", + "current_schema", + "current_time", + "current_timestamp", + "current_path", + "current_role", + "current_transform_group_for_type", + "current_user", + "cursor", + "cycle", + "date", + "day", + "deallocate", + "dec", + "decimal", + "decfloat", + "declare", + "default", + "define", + "delete", + "dense_rank", + "deref", + "describe", + "deterministic", + "disconnect", + "distinct", + "double", + "drop", + "dynamic", + "each", + "element", + "else", + "empty", + "end", + "end_frame", + "end_partition", + "end-exec", + "equals", + "escape", + "every", + "except", + "exec", + "execute", + "exists", + "exp", + "external", + "extract", + "false", + "fetch", + "filter", + "first_value", + "float", + "floor", + "for", + "foreign", + "frame_row", + "free", + "from", + "full", + "function", + "fusion", + "get", + "global", + "grant", + "group", + "grouping", + "groups", + "having", + "hold", + "hour", + "identity", + "in", + "indicator", + "initial", + "inner", + "inout", + "insensitive", + "insert", + "int", + "integer", + "intersect", + "intersection", + "interval", + "into", + "is", + "join", + "json_array", + "json_arrayagg", + "json_exists", + "json_object", + "json_objectagg", + "json_query", + "json_table", + "json_table_primitive", + "json_value", + "lag", + "language", + "large", + "last_value", + "lateral", + "lead", + "leading", + "left", + "like", + "like_regex", + "listagg", + "ln", + "local", + "localtime", + "localtimestamp", + "log", + "log10", + "lower", + "match", + "match_number", + "match_recognize", + "matches", + "max", + "member", + "merge", + "method", + "min", + "minute", + "mod", + "modifies", + "module", + "month", + "multiset", + "national", + "natural", + "nchar", + "nclob", + "new", + "no", + "none", + "normalize", + "not", + "nth_value", + "ntile", + "null", + "nullif", + "numeric", + "octet_length", + "occurrences_regex", + "of", + "offset", + "old", + "omit", + "on", + "one", + "only", + "open", + "or", + "order", + "out", + "outer", + "over", + "overlaps", + "overlay", + "parameter", + "partition", + "pattern", + "per", + "percent", + "percent_rank", + "percentile_cont", + "percentile_disc", + "period", + "portion", + "position", + "position_regex", + "power", + "precedes", + "precision", + "prepare", + "primary", + "procedure", + "ptf", + "range", + "rank", + "reads", + "real", + "recursive", + "ref", + "references", + "referencing", + "regr_avgx", + "regr_avgy", + "regr_count", + "regr_intercept", + "regr_r2", + "regr_slope", + "regr_sxx", + "regr_sxy", + "regr_syy", + "release", + "result", + "return", + "returns", + "revoke", + "right", + "rollback", + "rollup", + "row", + "row_number", + "rows", + "running", + "savepoint", + "scope", + "scroll", + "search", + "second", + "seek", + "select", + "sensitive", + "session_user", + "set", + "show", + "similar", + "sin", + "sinh", + "skip", + "smallint", + "some", + "specific", + "specifictype", + "sql", + "sqlexception", + "sqlstate", + "sqlwarning", + "sqrt", + "start", + "static", + "stddev_pop", + "stddev_samp", + "submultiset", + "subset", + "substring", + "substring_regex", + "succeeds", + "sum", + "symmetric", + "system", + "system_time", + "system_user", + "table", + "tablesample", + "tan", + "tanh", + "then", + "time", + "timestamp", + "timezone_hour", + "timezone_minute", + "to", + "trailing", + "translate", + "translate_regex", + "translation", + "treat", + "trigger", + "trim", + "trim_array", + "true", + "truncate", + "uescape", + "union", + "unique", + "unknown", + "unnest", + "update", + "upper", + "user", + "using", + "value", + "values", + "value_of", + "var_pop", + "var_samp", + "varbinary", + "varchar", + "varying", + "versioning", + "when", + "whenever", + "where", + "width_bucket", + "window", + "with", + "within", + "without", + "year" + ]; + const RESERVED_FUNCTIONS = [ + "abs", + "acos", + "array_agg", + "asin", + "atan", + "avg", + "cast", + "ceil", + "ceiling", + "coalesce", + "corr", + "cos", + "cosh", + "count", + "covar_pop", + "covar_samp", + "cume_dist", + "dense_rank", + "deref", + "element", + "exp", + "extract", + "first_value", + "floor", + "json_array", + "json_arrayagg", + "json_exists", + "json_object", + "json_objectagg", + "json_query", + "json_table", + "json_table_primitive", + "json_value", + "lag", + "last_value", + "lead", + "listagg", + "ln", + "log", + "log10", + "lower", + "max", + "min", + "mod", + "nth_value", + "ntile", + "nullif", + "percent_rank", + "percentile_cont", + "percentile_disc", + "position", + "position_regex", + "power", + "rank", + "regr_avgx", + "regr_avgy", + "regr_count", + "regr_intercept", + "regr_r2", + "regr_slope", + "regr_sxx", + "regr_sxy", + "regr_syy", + "row_number", + "sin", + "sinh", + "sqrt", + "stddev_pop", + "stddev_samp", + "substring", + "substring_regex", + "sum", + "tan", + "tanh", + "translate", + "translate_regex", + "treat", + "trim", + "trim_array", + "unnest", + "upper", + "value_of", + "var_pop", + "var_samp", + "width_bucket" + ]; + const POSSIBLE_WITHOUT_PARENS = [ + "current_catalog", + "current_date", + "current_default_transform_group", + "current_path", + "current_role", + "current_schema", + "current_transform_group_for_type", + "current_user", + "session_user", + "system_time", + "system_user", + "current_time", + "localtime", + "current_timestamp", + "localtimestamp" + ]; + const COMBOS = [ + "create table", + "insert into", + "primary key", + "foreign key", + "not null", + "alter table", + "add constraint", + "grouping sets", + "on overflow", + "character set", + "respect nulls", + "ignore nulls", + "nulls first", + "nulls last", + "depth first", + "breadth first" + ]; + const FUNCTIONS = RESERVED_FUNCTIONS; + const KEYWORDS3 = [ + ...RESERVED_WORDS, + ...NON_RESERVED_WORDS + ].filter((keyword) => { + return !RESERVED_FUNCTIONS.includes(keyword); + }); + const VARIABLE = { + scope: "variable", + match: /@[a-z0-9][a-z0-9_]*/ + }; + const OPERATOR = { + scope: "operator", + match: /[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/, + relevance: 0 + }; + const FUNCTION_CALL = { + match: regex.concat(/\b/, regex.either(...FUNCTIONS), /\s*\(/), + relevance: 0, + keywords: { built_in: FUNCTIONS } + }; + function kws_to_regex(list) { + return regex.concat(/\b/, regex.either(...list.map((kw) => { + return kw.replace(/\s+/, "\\s+"); + })), /\b/); + } + const MULTI_WORD_KEYWORDS = { + scope: "keyword", + match: kws_to_regex(COMBOS), + relevance: 0 + }; + function reduceRelevancy(list, { + exceptions, + when + } = {}) { + const qualifyFn = when; + exceptions = exceptions || []; + return list.map((item) => { + if (item.match(/\|\d+$/) || exceptions.includes(item)) { + return item; + } else if (qualifyFn(item)) { + return `${item}|0`; + } else { + return item; + } + }); + } + return { + name: "SQL", + case_insensitive: true, + illegal: /[{}]|<\//, + keywords: { + $pattern: /\b[\w\.]+/, + keyword: reduceRelevancy(KEYWORDS3, { when: (x2) => x2.length < 3 }), + literal: LITERALS3, + type: TYPES3, + built_in: POSSIBLE_WITHOUT_PARENS + }, + contains: [ + { + scope: "type", + match: kws_to_regex(MULTI_WORD_TYPES) + }, + MULTI_WORD_KEYWORDS, + FUNCTION_CALL, + VARIABLE, + STRING, + QUOTED_IDENTIFIER, + hljs.C_NUMBER_MODE, + hljs.C_BLOCK_COMMENT_MODE, + COMMENT_MODE, + OPERATOR + ] + }; + } + + // node_modules/highlight.js/es/languages/xml.js + function xml(hljs) { + const regex = hljs.regex; + const TAG_NAME_RE = regex.concat(/[\p{L}_]/u, regex.optional(/[\p{L}0-9_.-]*:/u), /[\p{L}0-9_.-]*/u); + const XML_IDENT_RE = /[\p{L}0-9._:-]+/u; + const XML_ENTITIES = { + className: "symbol", + begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/ + }; + const XML_META_KEYWORDS = { + begin: /\s/, + contains: [ + { + className: "keyword", + begin: /#?[a-z_][a-z1-9_-]+/, + illegal: /\n/ + } + ] + }; + const XML_META_PAR_KEYWORDS = hljs.inherit(XML_META_KEYWORDS, { + begin: /\(/, + end: /\)/ + }); + const APOS_META_STRING_MODE = hljs.inherit(hljs.APOS_STRING_MODE, { className: "string" }); + const QUOTE_META_STRING_MODE = hljs.inherit(hljs.QUOTE_STRING_MODE, { className: "string" }); + const TAG_INTERNALS = { + endsWithParent: true, + illegal: /`]+/ } + ] + } + ] + } + ] + }; + return { + name: "HTML, XML", + aliases: [ + "html", + "xhtml", + "rss", + "atom", + "xjb", + "xsd", + "xsl", + "plist", + "wsf", + "svg" + ], + case_insensitive: true, + unicodeRegex: true, + contains: [ + { + className: "meta", + begin: //, + relevance: 10, + contains: [ + XML_META_KEYWORDS, + QUOTE_META_STRING_MODE, + APOS_META_STRING_MODE, + XML_META_PAR_KEYWORDS, + { + begin: /\[/, + end: /\]/, + contains: [ + { + className: "meta", + begin: //, + contains: [ + XML_META_KEYWORDS, + XML_META_PAR_KEYWORDS, + QUOTE_META_STRING_MODE, + APOS_META_STRING_MODE + ] + } + ] + } + ] + }, + hljs.COMMENT(//, { relevance: 10 }), + { + begin: //, + relevance: 10 + }, + XML_ENTITIES, + { + className: "meta", + end: /\?>/, + variants: [ + { + begin: /<\?xml/, + relevance: 10, + contains: [ + QUOTE_META_STRING_MODE + ] + }, + { + begin: /<\?[a-z][a-z0-9]+/ + } + ] + }, + { + className: "tag", + begin: /)/, + end: />/, + keywords: { name: "style" }, + contains: [TAG_INTERNALS], + starts: { + end: /<\/style>/, + returnEnd: true, + subLanguage: [ + "css", + "xml" + ] + } + }, + { + className: "tag", + begin: /)/, + end: />/, + keywords: { name: "script" }, + contains: [TAG_INTERNALS], + starts: { + end: /<\/script>/, + returnEnd: true, + subLanguage: [ + "javascript", + "handlebars", + "xml" + ] + } + }, + { + className: "tag", + begin: /<>|<\/>/ + }, + { + className: "tag", + begin: regex.concat(//, />/, /\s/)))), + end: /\/?>/, + contains: [ + { + className: "name", + begin: TAG_NAME_RE, + relevance: 0, + starts: TAG_INTERNALS + } + ] + }, + { + className: "tag", + begin: regex.concat(/<\//, regex.lookahead(regex.concat(TAG_NAME_RE, />/))), + contains: [ + { + className: "name", + begin: TAG_NAME_RE, + relevance: 0 + }, + { + begin: />/, + relevance: 0, + endsParent: true + } + ] + } + ] + }; + } + + // node_modules/highlight.js/es/languages/css.js + var MODES = (hljs) => { + return { + IMPORTANT: { + scope: "meta", + begin: "!important" + }, + BLOCK_COMMENT: hljs.C_BLOCK_COMMENT_MODE, + HEXCOLOR: { + scope: "number", + begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/ + }, + FUNCTION_DISPATCH: { + className: "built_in", + begin: /[\w-]+(?=\()/ + }, + ATTRIBUTE_SELECTOR_MODE: { + scope: "selector-attr", + begin: /\[/, + end: /\]/, + illegal: "$", + contains: [ + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE + ] + }, + CSS_NUMBER_MODE: { + scope: "number", + begin: hljs.NUMBER_RE + "(" + "%|em|ex|ch|rem" + "|vw|vh|vmin|vmax" + "|cm|mm|in|pt|pc|px" + "|deg|grad|rad|turn" + "|s|ms" + "|Hz|kHz" + "|dpi|dpcm|dppx" + ")?", + relevance: 0 + }, + CSS_VARIABLE: { + className: "attr", + begin: /--[A-Za-z_][A-Za-z0-9_-]*/ + } + }; + }; + var HTML_TAGS = [ + "a", + "abbr", + "address", + "article", + "aside", + "audio", + "b", + "blockquote", + "body", + "button", + "canvas", + "caption", + "cite", + "code", + "dd", + "del", + "details", + "dfn", + "div", + "dl", + "dt", + "em", + "fieldset", + "figcaption", + "figure", + "footer", + "form", + "h1", + "h2", + "h3", + "h4", + "h5", + "h6", + "header", + "hgroup", + "html", + "i", + "iframe", + "img", + "input", + "ins", + "kbd", + "label", + "legend", + "li", + "main", + "mark", + "menu", + "nav", + "object", + "ol", + "optgroup", + "option", + "p", + "picture", + "q", + "quote", + "samp", + "section", + "select", + "source", + "span", + "strong", + "summary", + "sup", + "table", + "tbody", + "td", + "textarea", + "tfoot", + "th", + "thead", + "time", + "tr", + "ul", + "var", + "video" + ]; + var SVG_TAGS = [ + "defs", + "g", + "marker", + "mask", + "pattern", + "svg", + "switch", + "symbol", + "feBlend", + "feColorMatrix", + "feComponentTransfer", + "feComposite", + "feConvolveMatrix", + "feDiffuseLighting", + "feDisplacementMap", + "feFlood", + "feGaussianBlur", + "feImage", + "feMerge", + "feMorphology", + "feOffset", + "feSpecularLighting", + "feTile", + "feTurbulence", + "linearGradient", + "radialGradient", + "stop", + "circle", + "ellipse", + "image", + "line", + "path", + "polygon", + "polyline", + "rect", + "text", + "use", + "textPath", + "tspan", + "foreignObject", + "clipPath" + ]; + var TAGS = [ + ...HTML_TAGS, + ...SVG_TAGS + ]; + var MEDIA_FEATURES = [ + "any-hover", + "any-pointer", + "aspect-ratio", + "color", + "color-gamut", + "color-index", + "device-aspect-ratio", + "device-height", + "device-width", + "display-mode", + "forced-colors", + "grid", + "height", + "hover", + "inverted-colors", + "monochrome", + "orientation", + "overflow-block", + "overflow-inline", + "pointer", + "prefers-color-scheme", + "prefers-contrast", + "prefers-reduced-motion", + "prefers-reduced-transparency", + "resolution", + "scan", + "scripting", + "update", + "width", + "min-width", + "max-width", + "min-height", + "max-height" + ].sort().reverse(); + var PSEUDO_CLASSES = [ + "active", + "any-link", + "blank", + "checked", + "current", + "default", + "defined", + "dir", + "disabled", + "drop", + "empty", + "enabled", + "first", + "first-child", + "first-of-type", + "fullscreen", + "future", + "focus", + "focus-visible", + "focus-within", + "has", + "host", + "host-context", + "hover", + "indeterminate", + "in-range", + "invalid", + "is", + "lang", + "last-child", + "last-of-type", + "left", + "link", + "local-link", + "not", + "nth-child", + "nth-col", + "nth-last-child", + "nth-last-col", + "nth-last-of-type", + "nth-of-type", + "only-child", + "only-of-type", + "optional", + "out-of-range", + "past", + "placeholder-shown", + "read-only", + "read-write", + "required", + "right", + "root", + "scope", + "target", + "target-within", + "user-invalid", + "valid", + "visited", + "where" + ].sort().reverse(); + var PSEUDO_ELEMENTS = [ + "after", + "backdrop", + "before", + "cue", + "cue-region", + "first-letter", + "first-line", + "grammar-error", + "marker", + "part", + "placeholder", + "selection", + "slotted", + "spelling-error" + ].sort().reverse(); + var ATTRIBUTES = [ + "accent-color", + "align-content", + "align-items", + "align-self", + "alignment-baseline", + "all", + "anchor-name", + "animation", + "animation-composition", + "animation-delay", + "animation-direction", + "animation-duration", + "animation-fill-mode", + "animation-iteration-count", + "animation-name", + "animation-play-state", + "animation-range", + "animation-range-end", + "animation-range-start", + "animation-timeline", + "animation-timing-function", + "appearance", + "aspect-ratio", + "backdrop-filter", + "backface-visibility", + "background", + "background-attachment", + "background-blend-mode", + "background-clip", + "background-color", + "background-image", + "background-origin", + "background-position", + "background-position-x", + "background-position-y", + "background-repeat", + "background-size", + "baseline-shift", + "block-size", + "border", + "border-block", + "border-block-color", + "border-block-end", + "border-block-end-color", + "border-block-end-style", + "border-block-end-width", + "border-block-start", + "border-block-start-color", + "border-block-start-style", + "border-block-start-width", + "border-block-style", + "border-block-width", + "border-bottom", + "border-bottom-color", + "border-bottom-left-radius", + "border-bottom-right-radius", + "border-bottom-style", + "border-bottom-width", + "border-collapse", + "border-color", + "border-end-end-radius", + "border-end-start-radius", + "border-image", + "border-image-outset", + "border-image-repeat", + "border-image-slice", + "border-image-source", + "border-image-width", + "border-inline", + "border-inline-color", + "border-inline-end", + "border-inline-end-color", + "border-inline-end-style", + "border-inline-end-width", + "border-inline-start", + "border-inline-start-color", + "border-inline-start-style", + "border-inline-start-width", + "border-inline-style", + "border-inline-width", + "border-left", + "border-left-color", + "border-left-style", + "border-left-width", + "border-radius", + "border-right", + "border-right-color", + "border-right-style", + "border-right-width", + "border-spacing", + "border-start-end-radius", + "border-start-start-radius", + "border-style", + "border-top", + "border-top-color", + "border-top-left-radius", + "border-top-right-radius", + "border-top-style", + "border-top-width", + "border-width", + "bottom", + "box-align", + "box-decoration-break", + "box-direction", + "box-flex", + "box-flex-group", + "box-lines", + "box-ordinal-group", + "box-orient", + "box-pack", + "box-shadow", + "box-sizing", + "break-after", + "break-before", + "break-inside", + "caption-side", + "caret-color", + "clear", + "clip", + "clip-path", + "clip-rule", + "color", + "color-interpolation", + "color-interpolation-filters", + "color-profile", + "color-rendering", + "color-scheme", + "column-count", + "column-fill", + "column-gap", + "column-rule", + "column-rule-color", + "column-rule-style", + "column-rule-width", + "column-span", + "column-width", + "columns", + "contain", + "contain-intrinsic-block-size", + "contain-intrinsic-height", + "contain-intrinsic-inline-size", + "contain-intrinsic-size", + "contain-intrinsic-width", + "container", + "container-name", + "container-type", + "content", + "content-visibility", + "counter-increment", + "counter-reset", + "counter-set", + "cue", + "cue-after", + "cue-before", + "cursor", + "cx", + "cy", + "direction", + "display", + "dominant-baseline", + "empty-cells", + "enable-background", + "field-sizing", + "fill", + "fill-opacity", + "fill-rule", + "filter", + "flex", + "flex-basis", + "flex-direction", + "flex-flow", + "flex-grow", + "flex-shrink", + "flex-wrap", + "float", + "flood-color", + "flood-opacity", + "flow", + "font", + "font-display", + "font-family", + "font-feature-settings", + "font-kerning", + "font-language-override", + "font-optical-sizing", + "font-palette", + "font-size", + "font-size-adjust", + "font-smooth", + "font-smoothing", + "font-stretch", + "font-style", + "font-synthesis", + "font-synthesis-position", + "font-synthesis-small-caps", + "font-synthesis-style", + "font-synthesis-weight", + "font-variant", + "font-variant-alternates", + "font-variant-caps", + "font-variant-east-asian", + "font-variant-emoji", + "font-variant-ligatures", + "font-variant-numeric", + "font-variant-position", + "font-variation-settings", + "font-weight", + "forced-color-adjust", + "gap", + "glyph-orientation-horizontal", + "glyph-orientation-vertical", + "grid", + "grid-area", + "grid-auto-columns", + "grid-auto-flow", + "grid-auto-rows", + "grid-column", + "grid-column-end", + "grid-column-start", + "grid-gap", + "grid-row", + "grid-row-end", + "grid-row-start", + "grid-template", + "grid-template-areas", + "grid-template-columns", + "grid-template-rows", + "hanging-punctuation", + "height", + "hyphenate-character", + "hyphenate-limit-chars", + "hyphens", + "icon", + "image-orientation", + "image-rendering", + "image-resolution", + "ime-mode", + "initial-letter", + "initial-letter-align", + "inline-size", + "inset", + "inset-area", + "inset-block", + "inset-block-end", + "inset-block-start", + "inset-inline", + "inset-inline-end", + "inset-inline-start", + "isolation", + "justify-content", + "justify-items", + "justify-self", + "kerning", + "left", + "letter-spacing", + "lighting-color", + "line-break", + "line-height", + "line-height-step", + "list-style", + "list-style-image", + "list-style-position", + "list-style-type", + "margin", + "margin-block", + "margin-block-end", + "margin-block-start", + "margin-bottom", + "margin-inline", + "margin-inline-end", + "margin-inline-start", + "margin-left", + "margin-right", + "margin-top", + "margin-trim", + "marker", + "marker-end", + "marker-mid", + "marker-start", + "marks", + "mask", + "mask-border", + "mask-border-mode", + "mask-border-outset", + "mask-border-repeat", + "mask-border-slice", + "mask-border-source", + "mask-border-width", + "mask-clip", + "mask-composite", + "mask-image", + "mask-mode", + "mask-origin", + "mask-position", + "mask-repeat", + "mask-size", + "mask-type", + "masonry-auto-flow", + "math-depth", + "math-shift", + "math-style", + "max-block-size", + "max-height", + "max-inline-size", + "max-width", + "min-block-size", + "min-height", + "min-inline-size", + "min-width", + "mix-blend-mode", + "nav-down", + "nav-index", + "nav-left", + "nav-right", + "nav-up", + "none", + "normal", + "object-fit", + "object-position", + "offset", + "offset-anchor", + "offset-distance", + "offset-path", + "offset-position", + "offset-rotate", + "opacity", + "order", + "orphans", + "outline", + "outline-color", + "outline-offset", + "outline-style", + "outline-width", + "overflow", + "overflow-anchor", + "overflow-block", + "overflow-clip-margin", + "overflow-inline", + "overflow-wrap", + "overflow-x", + "overflow-y", + "overlay", + "overscroll-behavior", + "overscroll-behavior-block", + "overscroll-behavior-inline", + "overscroll-behavior-x", + "overscroll-behavior-y", + "padding", + "padding-block", + "padding-block-end", + "padding-block-start", + "padding-bottom", + "padding-inline", + "padding-inline-end", + "padding-inline-start", + "padding-left", + "padding-right", + "padding-top", + "page", + "page-break-after", + "page-break-before", + "page-break-inside", + "paint-order", + "pause", + "pause-after", + "pause-before", + "perspective", + "perspective-origin", + "place-content", + "place-items", + "place-self", + "pointer-events", + "position", + "position-anchor", + "position-visibility", + "print-color-adjust", + "quotes", + "r", + "resize", + "rest", + "rest-after", + "rest-before", + "right", + "rotate", + "row-gap", + "ruby-align", + "ruby-position", + "scale", + "scroll-behavior", + "scroll-margin", + "scroll-margin-block", + "scroll-margin-block-end", + "scroll-margin-block-start", + "scroll-margin-bottom", + "scroll-margin-inline", + "scroll-margin-inline-end", + "scroll-margin-inline-start", + "scroll-margin-left", + "scroll-margin-right", + "scroll-margin-top", + "scroll-padding", + "scroll-padding-block", + "scroll-padding-block-end", + "scroll-padding-block-start", + "scroll-padding-bottom", + "scroll-padding-inline", + "scroll-padding-inline-end", + "scroll-padding-inline-start", + "scroll-padding-left", + "scroll-padding-right", + "scroll-padding-top", + "scroll-snap-align", + "scroll-snap-stop", + "scroll-snap-type", + "scroll-timeline", + "scroll-timeline-axis", + "scroll-timeline-name", + "scrollbar-color", + "scrollbar-gutter", + "scrollbar-width", + "shape-image-threshold", + "shape-margin", + "shape-outside", + "shape-rendering", + "speak", + "speak-as", + "src", + "stop-color", + "stop-opacity", + "stroke", + "stroke-dasharray", + "stroke-dashoffset", + "stroke-linecap", + "stroke-linejoin", + "stroke-miterlimit", + "stroke-opacity", + "stroke-width", + "tab-size", + "table-layout", + "text-align", + "text-align-all", + "text-align-last", + "text-anchor", + "text-combine-upright", + "text-decoration", + "text-decoration-color", + "text-decoration-line", + "text-decoration-skip", + "text-decoration-skip-ink", + "text-decoration-style", + "text-decoration-thickness", + "text-emphasis", + "text-emphasis-color", + "text-emphasis-position", + "text-emphasis-style", + "text-indent", + "text-justify", + "text-orientation", + "text-overflow", + "text-rendering", + "text-shadow", + "text-size-adjust", + "text-transform", + "text-underline-offset", + "text-underline-position", + "text-wrap", + "text-wrap-mode", + "text-wrap-style", + "timeline-scope", + "top", + "touch-action", + "transform", + "transform-box", + "transform-origin", + "transform-style", + "transition", + "transition-behavior", + "transition-delay", + "transition-duration", + "transition-property", + "transition-timing-function", + "translate", + "unicode-bidi", + "user-modify", + "user-select", + "vector-effect", + "vertical-align", + "view-timeline", + "view-timeline-axis", + "view-timeline-inset", + "view-timeline-name", + "view-transition-name", + "visibility", + "voice-balance", + "voice-duration", + "voice-family", + "voice-pitch", + "voice-range", + "voice-rate", + "voice-stress", + "voice-volume", + "white-space", + "white-space-collapse", + "widows", + "width", + "will-change", + "word-break", + "word-spacing", + "word-wrap", + "writing-mode", + "x", + "y", + "z-index", + "zoom" + ].sort().reverse(); + function css(hljs) { + const regex = hljs.regex; + const modes = MODES(hljs); + const VENDOR_PREFIX = { begin: /-(webkit|moz|ms|o)-(?=[a-z])/ }; + const AT_MODIFIERS = "and or not only"; + const AT_PROPERTY_RE = /@-?\w[\w]*(-\w+)*/; + const IDENT_RE3 = "[a-zA-Z-][a-zA-Z0-9_-]*"; + const STRINGS = [ + hljs.APOS_STRING_MODE, + hljs.QUOTE_STRING_MODE + ]; + return { + name: "CSS", + case_insensitive: true, + illegal: /[=|'\$]/, + keywords: { keyframePosition: "from to" }, + classNameAliases: { + keyframePosition: "selector-tag" + }, + contains: [ + modes.BLOCK_COMMENT, + VENDOR_PREFIX, + modes.CSS_NUMBER_MODE, + { + className: "selector-id", + begin: /#[A-Za-z0-9_-]+/, + relevance: 0 + }, + { + className: "selector-class", + begin: "\\." + IDENT_RE3, + relevance: 0 + }, + modes.ATTRIBUTE_SELECTOR_MODE, + { + className: "selector-pseudo", + variants: [ + { begin: ":(" + PSEUDO_CLASSES.join("|") + ")" }, + { begin: ":(:)?(" + PSEUDO_ELEMENTS.join("|") + ")" } + ] + }, + modes.CSS_VARIABLE, + { + className: "attribute", + begin: "\\b(" + ATTRIBUTES.join("|") + ")\\b" + }, + { + begin: /:/, + end: /[;}{]/, + contains: [ + modes.BLOCK_COMMENT, + modes.HEXCOLOR, + modes.IMPORTANT, + modes.CSS_NUMBER_MODE, + ...STRINGS, + { + begin: /(url|data-uri)\(/, + end: /\)/, + relevance: 0, + keywords: { built_in: "url data-uri" }, + contains: [ + ...STRINGS, + { + className: "string", + begin: /[^)]/, + endsWithParent: true, + excludeEnd: true + } + ] + }, + modes.FUNCTION_DISPATCH + ] + }, + { + begin: regex.lookahead(/@/), + end: "[{;]", + relevance: 0, + illegal: /:/, + contains: [ + { + className: "keyword", + begin: AT_PROPERTY_RE + }, + { + begin: /\s/, + endsWithParent: true, + excludeEnd: true, + relevance: 0, + keywords: { + $pattern: /[a-z-]+/, + keyword: AT_MODIFIERS, + attribute: MEDIA_FEATURES.join(" ") + }, + contains: [ + { + begin: /[a-z-]+(?=:)/, + className: "attribute" + }, + ...STRINGS, + modes.CSS_NUMBER_MODE + ] + } + ] + }, + { + className: "selector-tag", + begin: "\\b(" + TAGS.join("|") + ")\\b" + } + ] + }; + } + + // node_modules/highlight.js/es/languages/markdown.js + function markdown(hljs) { + const regex = hljs.regex; + const INLINE_HTML = { + begin: /<\/?[A-Za-z_]/, + end: ">", + subLanguage: "xml", + relevance: 0 + }; + const HORIZONTAL_RULE = { + begin: "^[-\\*]{3,}", + end: "$" + }; + const CODE = { + className: "code", + variants: [ + { begin: "(`{3,})[^`](.|\\n)*?\\1`*[ ]*" }, + { begin: "(~{3,})[^~](.|\\n)*?\\1~*[ ]*" }, + { + begin: "```", + end: "```+[ ]*$" + }, + { + begin: "~~~", + end: "~~~+[ ]*$" + }, + { begin: "`.+?`" }, + { + begin: "(?=^( {4}|\\t))", + contains: [ + { + begin: "^( {4}|\\t)", + end: "(\\n)$" + } + ], + relevance: 0 + } + ] + }; + const LIST = { + className: "bullet", + begin: "^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)", + end: "\\s+", + excludeEnd: true + }; + const LINK_REFERENCE = { + begin: /^\[[^\n]+\]:/, + returnBegin: true, + contains: [ + { + className: "symbol", + begin: /\[/, + end: /\]/, + excludeBegin: true, + excludeEnd: true + }, + { + className: "link", + begin: /:\s*/, + end: /$/, + excludeBegin: true + } + ] + }; + const URL_SCHEME = /[A-Za-z][A-Za-z0-9+.-]*/; + const LINK = { + variants: [ + { + begin: /\[.+?\]\[.*?\]/, + relevance: 0 + }, + { + begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/, + relevance: 2 + }, + { + begin: regex.concat(/\[.+?\]\(/, URL_SCHEME, /:\/\/.*?\)/), + relevance: 2 + }, + { + begin: /\[.+?\]\([./?&#].*?\)/, + relevance: 1 + }, + { + begin: /\[.*?\]\(.*?\)/, + relevance: 0 + } + ], + returnBegin: true, + contains: [ + { + match: /\[(?=\])/ + }, + { + className: "string", + relevance: 0, + begin: "\\[", + end: "\\]", + excludeBegin: true, + returnEnd: true + }, + { + className: "link", + relevance: 0, + begin: "\\]\\(", + end: "\\)", + excludeBegin: true, + excludeEnd: true + }, + { + className: "symbol", + relevance: 0, + begin: "\\]\\[", + end: "\\]", + excludeBegin: true, + excludeEnd: true + } + ] + }; + const BOLD = { + className: "strong", + contains: [], + variants: [ + { + begin: /_{2}(?!\s)/, + end: /_{2}/ + }, + { + begin: /\*{2}(?!\s)/, + end: /\*{2}/ + } + ] + }; + const ITALIC = { + className: "emphasis", + contains: [], + variants: [ + { + begin: /\*(?![*\s])/, + end: /\*/ + }, + { + begin: /_(?![_\s])/, + end: /_/, + relevance: 0 + } + ] + }; + const BOLD_WITHOUT_ITALIC = hljs.inherit(BOLD, { contains: [] }); + const ITALIC_WITHOUT_BOLD = hljs.inherit(ITALIC, { contains: [] }); + BOLD.contains.push(ITALIC_WITHOUT_BOLD); + ITALIC.contains.push(BOLD_WITHOUT_ITALIC); + let CONTAINABLE = [ + INLINE_HTML, + LINK + ]; + [ + BOLD, + ITALIC, + BOLD_WITHOUT_ITALIC, + ITALIC_WITHOUT_BOLD + ].forEach((m2) => { + m2.contains = m2.contains.concat(CONTAINABLE); + }); + CONTAINABLE = CONTAINABLE.concat(BOLD, ITALIC); + const HEADER = { + className: "section", + variants: [ + { + begin: "^#{1,6}", + end: "$", + contains: CONTAINABLE + }, + { + begin: "(?=^.+?\\n[=-]{2,}$)", + contains: [ + { begin: "^[=-]*$" }, + { + begin: "^", + end: "\\n", + contains: CONTAINABLE + } + ] + } + ] + }; + const BLOCKQUOTE = { + className: "quote", + begin: "^>\\s+", + contains: CONTAINABLE, + end: "$" + }; + const ENTITY = { + scope: "literal", + match: /&([a-zA-Z0-9]+|#[0-9]{1,7}|#[Xx][0-9a-fA-F]{1,6});/ + }; + return { + name: "Markdown", + aliases: [ + "md", + "mkdown", + "mkd" + ], + contains: [ + HEADER, + INLINE_HTML, + LIST, + BOLD, + ITALIC, + BLOCKQUOTE, + CODE, + HORIZONTAL_RULE, + LINK, + LINK_REFERENCE, + ENTITY + ] + }; + } + // src/logs_view.js var SAFE_LEVELS = new Set(["debug", "info", "warn", "error"]); function stringifyFieldValue(value) { @@ -78,6 +7232,34 @@ } // src/app.js + core_default.registerLanguage("javascript", javascript); + core_default.registerLanguage("js", javascript); + core_default.registerLanguage("python", python); + core_default.registerLanguage("py", python); + core_default.registerLanguage("go", go); + core_default.registerLanguage("bash", bash); + core_default.registerLanguage("sh", bash); + core_default.registerLanguage("json", json); + core_default.registerLanguage("yaml", yaml); + core_default.registerLanguage("yml", yaml); + core_default.registerLanguage("typescript", typescript); + core_default.registerLanguage("ts", typescript); + core_default.registerLanguage("sql", sql); + core_default.registerLanguage("xml", xml); + core_default.registerLanguage("html", xml); + core_default.registerLanguage("css", css); + core_default.registerLanguage("markdown", markdown); + core_default.registerLanguage("md", markdown); + g.setOptions({ + highlight: function(code, lang) { + if (lang && core_default.getLanguage(lang)) { + return core_default.highlight(code, { language: lang }).value; + } + return core_default.highlightAuto(code).value; + }, + breaks: true, + gfm: true + }); var tg = window.Telegram.WebApp; tg.ready(); var API_BASE = location.origin; @@ -318,32 +7500,7 @@ }); } function renderSimpleMarkdown(text) { - var lines = text.split(` -`); - var out = []; - for (var i = 0;i < lines.length; i++) { - var line = lines[i]; - if (/^### /.test(line)) { - out.push('
    ' + escapeHtml2(line.slice(4)) + "
    "); - } else if (/^## /.test(line)) { - out.push('
    ' + escapeHtml2(line.slice(3)) + "
    "); - } else if (/^# /.test(line)) { - out.push('
    ' + escapeHtml2(line.slice(2)) + "
    "); - } else if (/^- \[x\] /.test(line)) { - out.push('
    ' + escapeHtml2(line.slice(6)) + "
    "); - } else if (/^- \[ \] /.test(line)) { - out.push('
    ' + escapeHtml2(line.slice(6)) + "
    "); - } else if (/^> /.test(line)) { - out.push('
    ' + escapeHtml2(line.slice(2)) + "
    "); - } else if (/^- /.test(line)) { - out.push('
    ' + escapeHtml2(line.slice(2)) + "
    "); - } else if (line.trim() === "") { - out.push("
    "); - } else { - out.push("
    " + escapeHtml2(line) + "
    "); - } - } - return out.join(""); + return g.parse(text); } async function loadTab(loadingId, contentId, label, fetchFn, renderFn) { var loading = document.getElementById(loadingId); @@ -527,12 +7684,12 @@ var ws = ctx.workspace || "—"; var filesHtml = ""; if (ctx.bootstrap && ctx.bootstrap.length) { - filesHtml = ctx.bootstrap.map(function(b) { - var path = b.path ? escapeHtml2(b.path) : "—"; - var scope = b.scope === "global" ? "global" : "project"; - var found = b.path ? "var(--text)" : "var(--hint)"; + filesHtml = ctx.bootstrap.map(function(b2) { + var path = b2.path ? escapeHtml2(b2.path) : "—"; + var scope = b2.scope === "global" ? "global" : "project"; + var found = b2.path ? "var(--text)" : "var(--hint)"; return `
    - ${escapeHtml2(b.name)} + ${escapeHtml2(b2.name)} ${path} ${scope}
    `; @@ -1381,7 +8538,7 @@ var msg; try { msg = JSON.parse(e.data); - } catch (_) { + } catch (_2) { return; } if (msg.type === "init") { @@ -1547,7 +8704,7 @@ var resp = await fetch(API_BASE + "/miniapp/api/research/" + taskId + "/doc/" + docId + "?initData=" + encodeURIComponent(initData)); var data = await resp.json(); body.dataset.loaded = "1"; - body.innerHTML = '
    ' + esc(data.content) + "
    "; + body.innerHTML = '
    ' + g.parse(data.content) + "
    "; } catch (e) { body.innerHTML = '
    Failed to load document.
    '; }