@moontra/moonui-pro
Version:
Premium React components for MoonUI - Advanced UI library with 50+ pro components including performance, interactive, and gesture components
1,427 lines (1,424 loc) • 2.65 MB
JavaScript
import { clsx } from 'clsx';
import { twMerge } from 'tailwind-merge';
import * as t from 'react';
import t__default, { useState, useRef, useMemo, useCallback, useEffect, forwardRef, createContext, useContext, useLayoutEffect, useDebugValue, Component } from 'react';
import * as AccordionPrimitive from '@radix-ui/react-accordion';
import { ChevronDown, Info, AlertCircle, AlertTriangle, Check, X, MoreHorizontal, Loader2, Minus, Search, ChevronRight, Circle, ChevronUp, Lock, Sparkles, ChevronLeft, ZoomOut, ZoomIn, Pause, Play, VolumeX, Volume2, Download, Maximize2, Filter, Image as Image$1, Video, Plus, RotateCw, Minimize2, PanelLeft, PanelRight, FileText, FileSpreadsheet, FileCode, Printer, Share2, Settings, Upload, Eye, CheckCircle2, RotateCcw, Copy, Share, Trash2, CreditCard, Globe, XCircle, Clock, HelpCircle, Calendar as Calendar$1, Repeat, Edit, MapPin, Users, User, Briefcase, ClipboardList, Bell, Cake, Tag, Move, Archive, EyeOff, Timer, Palette, ArrowUpDown, Star, Square, CheckSquare, Bold, Italic, Underline, Strikethrough, Code, Type, Heading1, Heading2, Heading3, AlignLeft, AlignCenter, AlignRight, AlignJustify, List, ListOrdered, Quote, Highlighter, Link2, Table as Table$1, Undo, Redo, RefreshCw, Wand2, Maximize, MessageSquare, Heart, GraduationCap, Zap, Languages, Lightbulb, Cpu, BarChart3, Target, GitBranch, ArrowRight, MoreVertical, Trash, ExternalLink, TrendingUp, MessageCircle, Paperclip, TrendingDown, FileJson, Menu, CheckCheck, CheckCircle, Settings2, LogOut, Edit3, LayoutGrid, Save, Music, File, FileDown, ArrowUp, ArrowDown, ChevronsLeft, ChevronsRight, Pin, Sun, Moon, Monitor, Activity, Send, Flag, CalendarIcon, DollarSign, Github, Server, MemoryStick, HardDrive, Network, Columns, Grip, Unlock, Map as Map$1, GitFork, Package, BellOff, ArrowDownRight, ArrowUpRight } from 'lucide-react';
import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
import { cva } from 'class-variance-authority';
import * as AvatarPrimitive from '@radix-ui/react-avatar';
import { startOfDay, endOfDay, addDays, startOfYear, endOfYear, startOfMonth, endOfMonth, startOfWeek, endOfWeek, isWithinInterval, isBefore, isAfter, subYears, addYears, subMonths, addMonths, subWeeks, addWeeks, subDays, addHours, setHours, setMinutes, differenceInMinutes, addMinutes, format, isSameDay, isToday, eachDayOfInterval, isSameMonth, eachMonthOfInterval, getDay, getDaysInMonth, formatDistanceToNow } from 'date-fns';
import { motion, useAnimation, useMotionValue, animate, AnimatePresence, useSpring, useTransform, LayoutGroup, Reorder, useDragControls } from 'framer-motion';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import * as ReactDOM from 'react-dom';
import ReactDOM__default from 'react-dom';
import { createSlot, createSlottable } from '@radix-ui/react-slot';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import { createDialogScope } from '@radix-ui/react-dialog';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import * as LabelPrimitive from '@radix-ui/react-label';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
import * as SelectPrimitive from '@radix-ui/react-select';
import * as SeparatorPrimitive from '@radix-ui/react-separator';
import * as SwitchPrimitives from '@radix-ui/react-switch';
import * as TabsPrimitive from '@radix-ui/react-tabs';
import * as ToastPrimitives from '@radix-ui/react-toast';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { useSyncExternalStore } from 'use-sync-external-store/shim/index.js';
import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector.js';
import { ResponsiveContainer, LineChart, Line, RadialBarChart, Tooltip, Legend, RadialBar, RadarChart, PolarGrid, PolarAngleAxis, PolarRadiusAxis, Radar, ScatterChart, CartesianGrid, XAxis, YAxis, Scatter, PieChart, Pie, Cell, AreaChart, Area, ReferenceLine, Brush, BarChart, Bar, ReferenceArea } from 'recharts';
import { WidthProvider, Responsive } from 'react-grid-layout';
import 'react-grid-layout/css/styles.css';
import { DragDropContext, Droppable, Draggable } from '@hello-pangea/dnd';
import { useForm } from 'react-hook-form';
import confetti from 'canvas-confetti';
import { flexRender, useReactTable, getCoreRowModel, getPaginationRowModel, getSortedRowModel, getFilteredRowModel } from '@tanstack/react-table';
/**
* @moontra/moonui-pro v2.0.9
* Premium UI components for MoonUI
* (c) 2025 MoonUI. All rights reserved.
* @license Commercial - https://moonui.dev/license
*/
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from2, except, desc) => {
if (from2 && typeof from2 === "object" || typeof from2 === "function") {
for (let key of __getOwnPropNames(from2))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// ../../node_modules/fast-deep-equal/es6/react.js
var require_react = __commonJS({
"../../node_modules/fast-deep-equal/es6/react.js"(exports, module) {
module.exports = function equal(a, b) {
if (a === b)
return true;
if (a && b && typeof a == "object" && typeof b == "object") {
if (a.constructor !== b.constructor)
return false;
var length, i, keys2;
if (Array.isArray(a)) {
length = a.length;
if (length != b.length)
return false;
for (i = length; i-- !== 0; )
if (!equal(a[i], b[i]))
return false;
return true;
}
if (a instanceof Map && b instanceof Map) {
if (a.size !== b.size)
return false;
for (i of a.entries())
if (!b.has(i[0]))
return false;
for (i of a.entries())
if (!equal(i[1], b.get(i[0])))
return false;
return true;
}
if (a instanceof Set && b instanceof Set) {
if (a.size !== b.size)
return false;
for (i of a.entries())
if (!b.has(i[0]))
return false;
return true;
}
if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
length = a.length;
if (length != b.length)
return false;
for (i = length; i-- !== 0; )
if (a[i] !== b[i])
return false;
return true;
}
if (a.constructor === RegExp)
return a.source === b.source && a.flags === b.flags;
if (a.valueOf !== Object.prototype.valueOf)
return a.valueOf() === b.valueOf();
if (a.toString !== Object.prototype.toString)
return a.toString() === b.toString();
keys2 = Object.keys(a);
length = keys2.length;
if (length !== Object.keys(b).length)
return false;
for (i = length; i-- !== 0; )
if (!Object.prototype.hasOwnProperty.call(b, keys2[i]))
return false;
for (i = length; i-- !== 0; ) {
var key = keys2[i];
if (key === "_owner" && a.$$typeof) {
continue;
}
if (!equal(a[key], b[key]))
return false;
}
return true;
}
return a !== a && b !== b;
};
}
});
// ../../node_modules/highlight.js/lib/core.js
var require_core = __commonJS({
"../../node_modules/highlight.js/lib/core.js"(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;
}
var Response = class {
/**
* @param {CompiledMode} mode
*/
constructor(mode) {
if (mode.data === void 0)
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, """).replace(/'/g, "'");
}
function inherit$1(original, ...objects) {
const result = /* @__PURE__ */ 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 (
/** @type {T} */
result
);
}
var SPAN_CLOSE = "</span>";
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((x, i) => `${x}${"_".repeat(i + 1)}`)
].join(" ");
}
return `${prefix}${name}`;
};
var HTMLRenderer = class {
/**
* Creates a new HTMLRenderer
*
* @param {Tree} parseTree - the parse tree (must support `walk` API)
* @param {{classPrefix: string}} options
*/
constructor(parseTree, options) {
this.buffer = "";
this.classPrefix = options.classPrefix;
parseTree.walk(this);
}
/**
* Adds texts to the output stream
*
* @param {string} text */
addText(text) {
this.buffer += escapeHTML(text);
}
/**
* Adds a node open to the output stream (if needed)
*
* @param {Node} node */
openNode(node) {
if (!emitsWrappingTags(node))
return;
const className = scopeToCSSClass(
node.scope,
{ prefix: this.classPrefix }
);
this.span(className);
}
/**
* Adds a node close to the output stream (if needed)
*
* @param {Node} node */
closeNode(node) {
if (!emitsWrappingTags(node))
return;
this.buffer += SPAN_CLOSE;
}
/**
* returns the accumulated buffer
*/
value() {
return this.buffer;
}
// helpers
/**
* Builds a span element
*
* @param {string} className */
span(className) {
this.buffer += `<span class="${className}">`;
}
};
var newNode = (opts = {}) => {
const result = { children: [] };
Object.assign(result, opts);
return result;
};
var TokenTree = class {
constructor() {
this.rootNode = newNode();
this.stack = [this.rootNode];
}
get top() {
return this.stack[this.stack.length - 1];
}
get root() {
return this.rootNode;
}
/** @param {Node} node */
add(node) {
this.top.children.push(node);
}
/** @param {string} scope */
openNode(scope) {
const node = newNode({ scope });
this.add(node);
this.stack.push(node);
}
closeNode() {
if (this.stack.length > 1) {
return this.stack.pop();
}
return void 0;
}
closeAllNodes() {
while (this.closeNode())
;
}
toJSON() {
return JSON.stringify(this.rootNode, null, 4);
}
/**
* @typedef { import("./html_renderer").Renderer } Renderer
* @param {Renderer} builder
*/
walk(builder) {
return this.constructor._walk(builder, this.rootNode);
}
/**
* @param {Renderer} builder
* @param {Node} node
*/
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;
}
/**
* @param {Node} node
*/
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);
});
}
}
};
var TokenTreeEmitter = class extends TokenTree {
/**
* @param {*} options
*/
constructor(options) {
super();
this.options = options;
}
/**
* @param {string} text
*/
addText(text) {
if (text === "") {
return;
}
this.add(text);
}
/** @param {string} scope */
startScope(scope) {
this.openNode(scope);
}
endScope() {
this.closeNode();
}
/**
* @param {Emitter & {root: DataNode}} emitter
* @param {string} name
*/
__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 source2(re) {
if (!re)
return null;
if (typeof re === "string")
return re;
return re.source;
}
function lookahead2(re) {
return concat2("(?=", re, ")");
}
function anyNumberOfTimes(re) {
return concat2("(?:", re, ")*");
}
function optional(re) {
return concat2("(?:", re, ")?");
}
function concat2(...args) {
const joined = args.map((x) => source2(x)).join("");
return joined;
}
function stripOptionsFromArgs2(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 either2(...args) {
const opts = stripOptionsFromArgs2(args);
const joined = "(" + (opts.capture ? "" : "?:") + args.map((x) => source2(x)).join("|") + ")";
return joined;
}
function countMatchGroups(re) {
return new RegExp(re.toString() + "|").exec("").length - 1;
}
function startsWith(re, lexeme) {
const match = re && re.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 offset4 = numCaptures;
let re = source2(regex);
let out = "";
while (re.length > 0) {
const match = BACKREF_RE.exec(re);
if (!match) {
out += re;
break;
}
out += re.substring(0, match.index);
re = re.substring(match.index + match[0].length);
if (match[0][0] === "\\" && match[1]) {
out += "\\" + String(Number(match[1]) + offset4);
} else {
out += match[0];
if (match[0] === "(") {
numCaptures++;
}
}
}
return out;
}).map((re) => `(${re})`).join(joinWith);
}
var MATCH_NOTHING_RE = /\b\B/;
var IDENT_RE3 = "[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 = concat2(
beginShebang,
/.*\b/,
opts.binary,
/\b.*/
);
}
return inherit$1({
scope: "meta",
begin: beginShebang,
end: /$/,
relevance: 0,
/** @type {ModeCallback} */
"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",
// hack to avoid the space from being included. the space is necessary to
// match here to prevent the plain text rule below from gobbling up doctags
begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
excludeBegin: true,
relevance: 0
});
const ENGLISH_WORD = either2(
// list of common 1 and 2 letter words in English
"I",
"a",
"is",
"so",
"us",
"to",
"at",
"if",
"in",
"it",
"on",
// note: this is not an exhaustive list of contractions, just popular ones
/[A-Za-z]+['](d|ve|re|ll|t|s|n)/,
// contractions - can't we'd they're let's, etc
/[A-Za-z]+[-][a-z]+/,
// `no-way`, etc.
/[A-Za-z][a-z]{2,}/
// allow capitalized words at beginning of sentences
);
mode.contains.push(
{
// TODO: how to include ", (, ) without breaking grammars that use these for
// comment delimiters?
// begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
// ---
// this tries to find sequences of 3 english words in a row (without any
// "programming" type syntax) this gives us a strong signal that we've
// TRULY found a comment - vs perhaps scanning with the wrong language.
// It's possible to find something that LOOKS like the start of the
// comment - but then if there is no readable text - good chance it is a
// false match and not a comment.
//
// for a visual example please see:
// https://github.com/highlightjs/highlight.js/issues/2827
begin: concat2(
/[ ]+/,
// necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
"(",
ENGLISH_WORD,
/[.]?[:]?([.][ ]|[ ])/,
"){3}"
)
// look for 3 words in a row
}
);
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_RE3,
relevance: 0
};
var UNDERSCORE_TITLE_MODE = {
scope: "title",
begin: UNDERSCORE_IDENT_RE,
relevance: 0
};
var METHOD_GUARD = {
// excludes method names from keyword processing
begin: "\\.\\s*" + UNDERSCORE_IDENT_RE,
relevance: 0
};
var END_SAME_AS_BEGIN = function(mode) {
return Object.assign(
mode,
{
/** @type {ModeCallback} */
"on:begin": (m2, resp) => {
resp.data._beginMatch = m2[1];
},
/** @type {ModeCallback} */
"on:end": (m2, resp) => {
if (resp.data._beginMatch !== m2[1])
resp.ignoreMatch();
}
}
);
};
var MODES4 = /* @__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: IDENT_RE3,
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 !== void 0) {
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 === void 0)
mode.relevance = 0;
}
function compileIllegal(mode, _parent) {
if (!Array.isArray(mode.illegal))
return;
mode.illegal = either2(...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 === void 0)
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 = concat2(originalMode.beforeMatch, lookahead2(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",
// common variable name
"list",
// common variable name
"value"
// common variable name
];
var DEFAULT_KEYWORD_SCOPE = "keyword";
function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
const compiledKeywords = /* @__PURE__ */ 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((x) => x.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 warn2 = (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 offset4 = 0;
const scopeNames = mode[key];
const emit = {};
const positions = {};
for (let i = 1; i <= regexes.length; i++) {
positions[i + offset4] = scopeNames[i];
emit[i + offset4] = true;
offset4 += 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(
source2(value),
"m" + (language.case_insensitive ? "i" : "") + (language.unicodeRegex ? "u" : "") + (global ? "g" : "")
);
}
class MultiRegex {
constructor() {
this.matchIndexes = {};
this.regexes = [];
this.matchAt = 1;
this.position = 0;
}
// @ts-ignore
addRule(re, opts) {
opts.position = this.position++;
this.matchIndexes[this.matchAt] = opts;
this.regexes.push([opts, re]);
this.matchAt += countMatchGroups(re) + 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;
}
/** @param {string} s */
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 !== void 0);
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;
}
// @ts-ignore
getMatcher(index2) {
if (this.multiRegexes[index2])
return this.multiRegexes[index2];
const matcher = new MultiRegex();
this.rules.slice(index2).forEach(([re, opts]) => matcher.addRule(re, opts));
matcher.compile();
this.multiRegexes[index2] = matcher;
return matcher;
}
resumingScanAtSamePosition() {
return this.regexIndex !== 0;
}
considerAll() {
this.regexIndex = 0;
}
// @ts-ignore
addRule(re, opts) {
this.rules.push([re, opts]);
if (opts.type === "begin")
this.count++;
}
/** @param {string} s */
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 = (
/** @type CompiledMode */
mode
);
if (mode.isCompiled)
return cmode;
[
scopeClassName,
// do this early so compiler extensions generally don't have to worry about
// the distinction between match/begin
compileMatch,
MultiClass,
beforeMatchExt
].forEach((ext) => ext(mode, parent));
language.compilerExtensions.forEach((ext) => ext(mode, parent));
mode.__beforeBegin = null;
[
beginKeywords,
// do this later so compiler extensions that come earlier have access to the
// raw array if they wanted to perhaps manipulate it, etc.
compileIllegal,
// default to 1 relevance if not specified
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 = source2(cmode.end) || "";
if (mode.endsWithParent && parent.terminatorEnd) {
cmode.terminatorEnd += (mode.end ? "|" : "") + parent.terminatorEnd;
}
}
if (mode.illegal)
cmode.illegalRe = langRe(
/** @type {RegExp | string} */
mode.illegal
);
if (!mode.contains)
mode.contains = [];
mode.contains = [].concat(...mode.contains.map(function(c2) {
return expandOrCloneMode(c2 === "self" ? mode : c2);
}));
mode.contains.forEach(function(c2) {
compileMode(
/** @type Mode */
c2,
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(
/** @type Mode */
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";
var HTMLInjectionError = class 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 = /* @__PURE__ */ Object.create(null);
const aliases = /* @__PURE__ */ 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,
// beta configuration options, subject to change, welcome to discuss
// https://github.com/highlightjs/highlight.js/issues/1086
__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) {
warn2(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
warn2("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.\nhttps://github.com/highlightjs/highlight.js/issues/2277");
languageName = codeOrLanguageName;
code = optionsOrCode;
}
if (ignoreIllegals === void 0) {
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 = /* @__PURE__ */ 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] = /** @type {CompiledMode} */
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 max2 = match.length - 1;
while (i <= max2) {
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 || "<unnamed>") + '"');
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 += "\n";
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 index2 = 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 = index2;
const match = top.matcher.exec(codeToHighlight);
if (!match)
break;
const beforeMatch = codeToH